@bessemer/cornerstone 0.5.86 → 0.5.89

package/dist/temporal/duration.js

@@ -0,0 +1,162 @@
+// src/temporal/duration.ts
+import Zod from "zod";
+import { Temporal } from "@js-temporal/polyfill";
+import { namespace } from "@bessemer/cornerstone/resource-key";
+import { fromComparator } from "@bessemer/cornerstone/equalitor";
+import { structuredTransform } from "@bessemer/cornerstone/zod-util";
+import { failure, mapResult, success } from "@bessemer/cornerstone/result";
+import { invalidValue, unpackResult } from "@bessemer/cornerstone/error/error-event";
+import { isError } from "@bessemer/cornerstone/error/error";
+import { TimeUnit } from "@bessemer/cornerstone/temporal/chrono";
+import { isString } from "@bessemer/cornerstone/string";
+var Namespace = namespace("duration");
+var from = (value) => {
+  if (value instanceof Temporal.Duration) {
+    return value;
+  }
+  if (isString(value)) {
+    return fromString(value);
+  }
+  return Temporal.Duration.from(value);
+};
+var CompareBy = (first, second) => Temporal.Duration.compare(first, second);
+var EqualBy = fromComparator(CompareBy);
+var parseString = (value) => {
+  try {
+    return success(Temporal.Duration.from(value));
+  } catch (e) {
+    if (!isError(e)) {
+      throw e;
+    }
+    return failure(invalidValue(value, { namespace: Namespace, message: e.message }));
+  }
+};
+var fromString = (value) => {
+  return unpackResult(parseString(value));
+};
+var toLiteral = (value) => {
+  return from(value).toString();
+};
+var SchemaLiteral = structuredTransform(Zod.string(), (it) => mapResult(parseString(it), toLiteral));
+var SchemaInstance = structuredTransform(Zod.string(), parseString);
+var isDuration = (value) => {
+  return value instanceof Temporal.Duration;
+};
+var merge = (element, builder) => {
+  return from(element).with(builder);
+};
+var fromMilliseconds = (value) => {
+  return from({ milliseconds: value });
+};
+var toMilliseconds = (duration) => {
+  return from(duration).total(TimeUnit.Millisecond);
+};
+var fromSeconds = (value) => {
+  return from({ seconds: value });
+};
+var toSeconds = (duration) => {
+  return from(duration).total(TimeUnit.Second);
+};
+var fromMinutes = (value) => {
+  return from({ minutes: value });
+};
+var toMinutes = (duration) => {
+  return from(duration).total(TimeUnit.Minute);
+};
+var fromHours = (value) => {
+  return from({ hours: value });
+};
+var toHours = (duration) => {
+  return from(duration).total(TimeUnit.Hour);
+};
+var fromUnit = (value, timeUnit) => {
+  switch (timeUnit) {
+    case TimeUnit.Nanosecond:
+      return from({ nanoseconds: value });
+    case TimeUnit.Microsecond:
+      return from({ microseconds: value });
+    case TimeUnit.Millisecond:
+      return from({ milliseconds: value });
+    case TimeUnit.Second:
+      return from({ seconds: value });
+    case TimeUnit.Minute:
+      return from({ minutes: value });
+    case TimeUnit.Hour:
+      return from({ hours: value });
+  }
+};
+var toUnit = (duration, timeUnit) => {
+  return from(duration).total(timeUnit);
+};
+var isZero = (duration) => {
+  return EqualBy(from(duration), Zero);
+};
+var round = (element, unit) => {
+  return from(element).round({ smallestUnit: unit });
+};
+var add = (...durations) => {
+  return durations.map(from).reduce((first, second) => first.add(second), Zero);
+};
+var subtract = (...durations) => {
+  if (durations.length === 0) {
+    return Zero;
+  }
+  const instances = durations.map(from);
+  return instances.slice(1).reduce((result, current) => result.subtract(current), instances[0]);
+};
+var negate = (element) => {
+  return from(element).negated();
+};
+var isEqual = (element, other) => {
+  return EqualBy(from(element), from(other));
+};
+var isLess = (element, other) => {
+  return CompareBy(from(element), from(other)) < 0;
+};
+var isGreater = (element, other) => {
+  return CompareBy(from(element), from(other)) > 0;
+};
+var Zero = from({ nanoseconds: 0 });
+var OneMillisecond = fromMilliseconds(1);
+var OneSecond = fromSeconds(1);
+var OneMinute = fromMinutes(1);
+var OneHour = fromHours(1);
+var OneDay = fromHours(24);
+export {
+  CompareBy,
+  EqualBy,
+  Namespace,
+  OneDay,
+  OneHour,
+  OneMillisecond,
+  OneMinute,
+  OneSecond,
+  SchemaInstance,
+  SchemaLiteral,
+  Zero,
+  add,
+  from,
+  fromHours,
+  fromMilliseconds,
+  fromMinutes,
+  fromSeconds,
+  fromString,
+  fromUnit,
+  isDuration,
+  isEqual,
+  isGreater,
+  isLess,
+  isZero,
+  merge,
+  negate,
+  parseString,
+  round,
+  subtract,
+  toHours,
+  toLiteral,
+  toMilliseconds,
+  toMinutes,
+  toSeconds,
+  toUnit
+};
+//# sourceMappingURL=duration.js.map

package/dist/temporal/duration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/temporal/duration.ts"],"sourcesContent":["import Zod from 'zod'\nimport { Temporal } from '@js-temporal/polyfill'\nimport { namespace } from '@bessemer/cornerstone/resource-key'\nimport { NominalType } from '@bessemer/cornerstone/types'\nimport { Comparator } from '@bessemer/cornerstone/comparator'\nimport { fromComparator } from '@bessemer/cornerstone/equalitor'\nimport { structuredTransform } from '@bessemer/cornerstone/zod-util'\nimport { failure, mapResult, Result, success } from '@bessemer/cornerstone/result'\nimport { ErrorEvent, invalidValue, unpackResult } from '@bessemer/cornerstone/error/error-event'\nimport { isError } from '@bessemer/cornerstone/error/error'\nimport { TimeUnit } from '@bessemer/cornerstone/temporal/chrono'\nimport { isString } from '@bessemer/cornerstone/string'\n\nexport type Duration = Temporal.Duration\nexport const Namespace = namespace('duration')\nexport type DurationLiteral = NominalType<string, typeof Namespace>\nexport type DurationBuilder = {\n  hours?: number\n  minutes?: number\n  seconds?: number\n  milliseconds?: number\n  microseconds?: number\n  nanoseconds?: number\n}\nexport type DurationLike = Duration | DurationLiteral | DurationBuilder\n\nexport const from = (value: DurationLike): Duration => {\n  if (value instanceof Temporal.Duration) {\n    return value\n  }\n  if (isString(value)) {\n    return fromString(value)\n  }\n\n  return Temporal.Duration.from(value)\n}\n\nexport const CompareBy: Comparator<Duration> = (first: Duration, second: Duration): number => Temporal.Duration.compare(first, second)\nexport const EqualBy = fromComparator(CompareBy)\n\nexport const parseString = (value: string): Result<Duration, ErrorEvent> => {\n  try {\n    return success(Temporal.Duration.from(value))\n  } catch (e) {\n    if (!isError(e)) {\n      throw e\n    }\n\n    return failure(invalidValue(value, { namespace: Namespace, message: e.message }))\n  }\n}\n\nexport const fromString = (value: string): Duration => {\n  return unpackResult(parseString(value))\n}\n\nexport const toLiteral = (value: DurationLike): DurationLiteral => {\n  return from(value).toString() as DurationLiteral\n}\n\nexport const SchemaLiteral = structuredTransform(Zod.string(), (it: string) => mapResult(parseString(it), toLiteral))\nexport const SchemaInstance = structuredTransform(Zod.string(), parseString)\n\nexport const isDuration = (value: unknown): value is Duration => {\n  return value instanceof Temporal.Duration\n}\n\nexport const merge = (element: DurationLike, builder: DurationBuilder): Duration => {\n  return from(element).with(builder)\n}\n\nexport const fromMilliseconds = (value: number): Duration => {\n  return from({ milliseconds: value })\n}\n\nexport const toMilliseconds = (duration: DurationLike): number => {\n  return from(duration).total(TimeUnit.Millisecond)\n}\n\nexport const fromSeconds = (value: number): Duration => {\n  return from({ seconds: value })\n}\n\nexport const toSeconds = (duration: DurationLike): number => {\n  return from(duration).total(TimeUnit.Second)\n}\n\nexport const fromMinutes = (value: number): Duration => {\n  return from({ minutes: value })\n}\n\nexport const toMinutes = (duration: DurationLike): number => {\n  return from(duration).total(TimeUnit.Minute)\n}\n\nexport const fromHours = (value: number): Duration => {\n  return from({ hours: value })\n}\n\nexport const toHours = (duration: DurationLike): number => {\n  return from(duration).total(TimeUnit.Hour)\n}\n\nexport const fromUnit = (value: number, timeUnit: TimeUnit): Duration => {\n  switch (timeUnit) {\n    case TimeUnit.Nanosecond:\n      return from({ nanoseconds: value })\n    case TimeUnit.Microsecond:\n      return from({ microseconds: value })\n    case TimeUnit.Millisecond:\n      return from({ milliseconds: value })\n    case TimeUnit.Second:\n      return from({ seconds: value })\n    case TimeUnit.Minute:\n      return from({ minutes: value })\n    case TimeUnit.Hour:\n      return from({ hours: value })\n  }\n}\n\nexport const toUnit = (duration: DurationLike, timeUnit: TimeUnit): number => {\n  return from(duration).total(timeUnit)\n}\n\nexport const isZero = (duration: DurationLike): boolean => {\n  return EqualBy(from(duration), Zero)\n}\n\nexport const round = (element: DurationLike, unit: TimeUnit): Duration => {\n  return from(element).round({ smallestUnit: unit })\n}\n\nexport const add = (...durations: Array<DurationLike>): Duration => {\n  return durations.map(from).reduce((first, second) => first.add(second), Zero)\n}\n\nexport const subtract = (...durations: Array<DurationLike>): Duration => {\n  if (durations.length === 0) {\n    return Zero\n  }\n\n  const instances = durations.map(from)\n  return instances.slice(1).reduce((result, current) => result.subtract(current), instances[0]!)\n}\n\nexport const negate = (element: DurationLike): Duration => {\n  return from(element).negated()\n}\n\nexport const isEqual = (element: DurationLike, other: DurationLike): boolean => {\n  return EqualBy(from(element), from(other))\n}\n\nexport const isLess = (element: DurationLike, other: DurationLike): boolean => {\n  return CompareBy(from(element), from(other)) < 0\n}\n\nexport const isGreater = (element: DurationLike, other: DurationLike): boolean => {\n  return CompareBy(from(element), from(other)) > 0\n}\n\nexport const Zero = from({ nanoseconds: 0 })\nexport const OneMillisecond = fromMilliseconds(1)\nexport const OneSecond = fromSeconds(1)\nexport const OneMinute = fromMinutes(1)\nexport const OneHour = fromHours(1)\nexport const OneDay = fromHours(24)\n"],"mappings":"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","names":[]}

package/dist/temporal/instant.d.ts

@@ -0,0 +1,35 @@
+import { Temporal } from '@js-temporal/polyfill';
+import { NominalType } from '@bessemer/cornerstone/types';
+import { Comparator } from '@bessemer/cornerstone/comparator';
+import { Result } from '@bessemer/cornerstone/result';
+import { ErrorEvent } from '@bessemer/cornerstone/error/error-event';
+import Zod from 'zod';
+import { Duration, DurationLike } from '@bessemer/cornerstone/temporal/duration';
+import { TimeUnit } from '@bessemer/cornerstone/temporal/chrono';
+export type Instant = Temporal.Instant;
+export declare const Namespace: import("@bessemer/cornerstone/resource-key").ResourceNamespace<"instant">;
+export type InstantLiteral = NominalType<string, typeof Namespace>;
+export type InstantLike = Instant | Date | InstantLiteral;
+export declare const from: (value: InstantLike) => Instant;
+export declare const CompareBy: Comparator<Instant>;
+export declare const EqualBy: import("@bessemer/cornerstone/equalitor").Equalitor<Temporal.Instant>;
+export declare const parseString: (value: string) => Result<Instant, ErrorEvent>;
+export declare const fromString: (value: string) => Instant;
+export declare const toLiteral: (value: InstantLike) => InstantLiteral;
+export declare const toDate: (value: Instant) => Date;
+export declare const SchemaLiteral: Zod.ZodPipe<Zod.ZodString, Zod.ZodTransform<InstantLiteral, string>>;
+export declare const SchemaInstance: Zod.ZodPipe<Zod.ZodString, Zod.ZodTransform<Temporal.Instant, string>>;
+export declare const isInstant: (value: unknown) => value is Instant;
+export declare const now: (clock?: {
+    readonly zone: import("./time-zone-id").TimeZoneId;
+    instant(): Instant;
+    withZone(zone: import("./time-zone-id").TimeZoneId): import("@bessemer/cornerstone/temporal/clock").Clock;
+}) => Instant;
+export declare const add: (element: InstantLike, duration: DurationLike) => Instant;
+export declare const subtract: (element: InstantLike, duration: DurationLike) => Instant;
+export declare const until: (element: InstantLike, other: InstantLike) => Duration;
+export declare const round: (element: InstantLike, unit: TimeUnit) => Instant;
+export declare const isEqual: (element: InstantLike, other: InstantLike) => boolean;
+export declare const isBefore: (element: InstantLike, other: InstantLike) => boolean;
+export declare const isAfter: (element: InstantLike, other: InstantLike) => boolean;
+//# sourceMappingURL=instant.d.ts.map

package/dist/temporal/instant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instant.d.ts","sourceRoot":"","sources":["../../src/temporal/instant.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAEhD,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAA;AAE7D,OAAO,EAAsB,MAAM,EAAW,MAAM,8BAA8B,CAAA;AAClF,OAAO,EAAE,UAAU,EAA8B,MAAM,yCAAyC,CAAA;AAGhG,OAAO,GAAG,MAAM,KAAK,CAAA;AAErB,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAwB,MAAM,yCAAyC,CAAA;AACtG,OAAO,EAAgC,QAAQ,EAAE,MAAM,uCAAuC,CAAA;AAG9F,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAA;AACtC,eAAO,MAAM,SAAS,2EAAuB,CAAA;AAC7C,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,MAAM,EAAE,OAAO,SAAS,CAAC,CAAA;AAClE,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,IAAI,GAAG,cAAc,CAAA;AAEzD,eAAO,MAAM,IAAI,GAAI,OAAO,WAAW,KAAG,OASzC,CAAA;AAED,eAAO,MAAM,SAAS,EAAE,UAAU,CAAC,OAAO,CAAwF,CAAA;AAClI,eAAO,MAAM,OAAO,uEAA4B,CAAA;AAEhD,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,KAAG,MAAM,CAAC,OAAO,EAAE,UAAU,CAUrE,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,KAAG,OAE1C,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,OAAO,WAAW,mBAE3C,CAAA;AAED,eAAO,MAAM,MAAM,GAAI,OAAO,OAAO,KAAG,IAEvC,CAAA;AAED,eAAO,MAAM,aAAa,sEAA2F,CAAA;AACrH,eAAO,MAAM,cAAc,wEAAiD,CAAA;AAE5E,eAAO,MAAM,SAAS,sCAAa,CAAA;AAEnC,eAAO,MAAM,GAAG,GAAI;;;;CAAoB,KAAG,OAE1C,CAAA;AAED,eAAO,MAAM,GAAG,GAAI,SAAS,WAAW,EAAE,UAAU,YAAY,KAAG,OAElE,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,SAAS,WAAW,EAAE,UAAU,YAAY,KAAG,OAEvE,CAAA;AAED,eAAO,MAAM,KAAK,GAAI,SAAS,WAAW,EAAE,OAAO,WAAW,KAAG,QAEhE,CAAA;AAED,eAAO,MAAM,KAAK,GAAI,SAAS,WAAW,EAAE,MAAM,QAAQ,KAAG,OAE5D,CAAA;AAED,eAAO,MAAM,OAAO,GAAI,SAAS,WAAW,EAAE,OAAO,WAAW,KAAG,OAElE,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,SAAS,WAAW,EAAE,OAAO,WAAW,KAAG,OAEnE,CAAA;AAED,eAAO,MAAM,OAAO,GAAI,SAAS,WAAW,EAAE,OAAO,WAAW,KAAG,OAElE,CAAA"}

package/dist/temporal/instant.js

@@ -0,0 +1,93 @@
+// src/temporal/instant.ts
+import { Temporal } from "@js-temporal/polyfill";
+import { namespace } from "@bessemer/cornerstone/resource-key";
+import { fromComparator } from "@bessemer/cornerstone/equalitor";
+import { failure, mapResult, success } from "@bessemer/cornerstone/result";
+import { invalidValue, unpackResult } from "@bessemer/cornerstone/error/error-event";
+import { isError } from "@bessemer/cornerstone/error/error";
+import { structuredTransform } from "@bessemer/cornerstone/zod-util";
+import Zod from "zod";
+import { Default as DefaultClock } from "@bessemer/cornerstone/temporal/clock";
+import { from as fromDuration } from "@bessemer/cornerstone/temporal/duration";
+import { _isInstant, instantToLiteral } from "@bessemer/cornerstone/temporal/chrono";
+import { isString } from "@bessemer/cornerstone/string";
+var Namespace = namespace("instant");
+var from = (value) => {
+  if (value instanceof Temporal.Instant) {
+    return value;
+  }
+  if (isString(value)) {
+    return fromString(value);
+  }
+  return Temporal.Instant.fromEpochMilliseconds(value.getTime());
+};
+var CompareBy = (first, second) => Temporal.Instant.compare(first, second);
+var EqualBy = fromComparator(CompareBy);
+var parseString = (value) => {
+  try {
+    return success(Temporal.Instant.from(value));
+  } catch (e) {
+    if (!isError(e)) {
+      throw e;
+    }
+    return failure(invalidValue(value, { namespace: Namespace, message: e.message }));
+  }
+};
+var fromString = (value) => {
+  return unpackResult(parseString(value));
+};
+var toLiteral = (value) => {
+  return instantToLiteral(from(value));
+};
+var toDate = (value) => {
+  return new Date(value.epochMilliseconds);
+};
+var SchemaLiteral = structuredTransform(Zod.string(), (it) => mapResult(parseString(it), toLiteral));
+var SchemaInstance = structuredTransform(Zod.string(), parseString);
+var isInstant = _isInstant;
+var now = (clock = DefaultClock) => {
+  return clock.instant();
+};
+var add = (element, duration) => {
+  return from(element).add(fromDuration(duration));
+};
+var subtract = (element, duration) => {
+  return from(element).subtract(fromDuration(duration));
+};
+var until = (element, other) => {
+  return from(element).until(from(other));
+};
+var round = (element, unit) => {
+  return from(element).round({ smallestUnit: unit });
+};
+var isEqual = (element, other) => {
+  return EqualBy(from(element), from(other));
+};
+var isBefore = (element, other) => {
+  return CompareBy(from(element), from(other)) < 0;
+};
+var isAfter = (element, other) => {
+  return CompareBy(from(element), from(other)) > 0;
+};
+export {
+  CompareBy,
+  EqualBy,
+  Namespace,
+  SchemaInstance,
+  SchemaLiteral,
+  add,
+  from,
+  fromString,
+  isAfter,
+  isBefore,
+  isEqual,
+  isInstant,
+  now,
+  parseString,
+  round,
+  subtract,
+  toDate,
+  toLiteral,
+  until
+};
+//# sourceMappingURL=instant.js.map

package/dist/temporal/instant.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/temporal/instant.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill'\nimport { namespace } from '@bessemer/cornerstone/resource-key'\nimport { NominalType } from '@bessemer/cornerstone/types'\nimport { Comparator } from '@bessemer/cornerstone/comparator'\nimport { fromComparator } from '@bessemer/cornerstone/equalitor'\nimport { failure, mapResult, Result, success } from '@bessemer/cornerstone/result'\nimport { ErrorEvent, invalidValue, unpackResult } from '@bessemer/cornerstone/error/error-event'\nimport { isError } from '@bessemer/cornerstone/error/error'\nimport { structuredTransform } from '@bessemer/cornerstone/zod-util'\nimport Zod from 'zod'\nimport { Default as DefaultClock } from '@bessemer/cornerstone/temporal/clock'\nimport { Duration, DurationLike, from as fromDuration } from '@bessemer/cornerstone/temporal/duration'\nimport { _isInstant, instantToLiteral, TimeUnit } from '@bessemer/cornerstone/temporal/chrono'\nimport { isString } from '@bessemer/cornerstone/string'\n\nexport type Instant = Temporal.Instant\nexport const Namespace = namespace('instant')\nexport type InstantLiteral = NominalType<string, typeof Namespace>\nexport type InstantLike = Instant | Date | InstantLiteral\n\nexport const from = (value: InstantLike): Instant => {\n  if (value instanceof Temporal.Instant) {\n    return value\n  }\n  if (isString(value)) {\n    return fromString(value)\n  }\n\n  return Temporal.Instant.fromEpochMilliseconds(value.getTime())\n}\n\nexport const CompareBy: Comparator<Instant> = (first: Instant, second: Instant): number => Temporal.Instant.compare(first, second)\nexport const EqualBy = fromComparator(CompareBy)\n\nexport const parseString = (value: string): Result<Instant, ErrorEvent> => {\n  try {\n    return success(Temporal.Instant.from(value))\n  } catch (e) {\n    if (!isError(e)) {\n      throw e\n    }\n\n    return failure(invalidValue(value, { namespace: Namespace, message: e.message }))\n  }\n}\n\nexport const fromString = (value: string): Instant => {\n  return unpackResult(parseString(value))\n}\n\nexport const toLiteral = (value: InstantLike) => {\n  return instantToLiteral(from(value))\n}\n\nexport const toDate = (value: Instant): Date => {\n  return new Date(value.epochMilliseconds)\n}\n\nexport const SchemaLiteral = structuredTransform(Zod.string(), (it: string) => mapResult(parseString(it), toLiteral))\nexport const SchemaInstance = structuredTransform(Zod.string(), parseString)\n\nexport const isInstant = _isInstant\n\nexport const now = (clock = DefaultClock): Instant => {\n  return clock.instant()\n}\n\nexport const add = (element: InstantLike, duration: DurationLike): Instant => {\n  return from(element).add(fromDuration(duration))\n}\n\nexport const subtract = (element: InstantLike, duration: DurationLike): Instant => {\n  return from(element).subtract(fromDuration(duration))\n}\n\nexport const until = (element: InstantLike, other: InstantLike): Duration => {\n  return from(element).until(from(other))\n}\n\nexport const round = (element: InstantLike, unit: TimeUnit): Instant => {\n  return from(element).round({ smallestUnit: unit })\n}\n\nexport const isEqual = (element: InstantLike, other: InstantLike): boolean => {\n  return EqualBy(from(element), from(other))\n}\n\nexport const isBefore = (element: InstantLike, other: InstantLike): boolean => {\n  return CompareBy(from(element), from(other)) < 0\n}\n\nexport const isAfter = (element: InstantLike, other: InstantLike): boolean => {\n  return CompareBy(from(element), from(other)) > 0\n}\n"],"mappings":";AAAA,SAAS,gBAAgB;AACzB,SAAS,iBAAiB;AAG1B,SAAS,sBAAsB;AAC/B,SAAS,SAAS,WAAmB,eAAe;AACpD,SAAqB,cAAc,oBAAoB;AACvD,SAAS,eAAe;AACxB,SAAS,2BAA2B;AACpC,OAAO,SAAS;AAChB,SAAS,WAAW,oBAAoB;AACxC,SAAiC,QAAQ,oBAAoB;AAC7D,SAAS,YAAY,wBAAkC;AACvD,SAAS,gBAAgB;AAGlB,IAAM,YAAY,UAAU,SAAS;AAIrC,IAAM,OAAO,CAAC,UAAgC;AACnD,MAAI,iBAAiB,SAAS,SAAS;AACrC,WAAO;AAAA,EACT;AACA,MAAI,SAAS,KAAK,GAAG;AACnB,WAAO,WAAW,KAAK;AAAA,EACzB;AAEA,SAAO,SAAS,QAAQ,sBAAsB,MAAM,QAAQ,CAAC;AAC/D;AAEO,IAAM,YAAiC,CAAC,OAAgB,WAA4B,SAAS,QAAQ,QAAQ,OAAO,MAAM;AAC1H,IAAM,UAAU,eAAe,SAAS;AAExC,IAAM,cAAc,CAAC,UAA+C;AACzE,MAAI;AACF,WAAO,QAAQ,SAAS,QAAQ,KAAK,KAAK,CAAC;AAAA,EAC7C,SAAS,GAAG;AACV,QAAI,CAAC,QAAQ,CAAC,GAAG;AACf,YAAM;AAAA,IACR;AAEA,WAAO,QAAQ,aAAa,OAAO,EAAE,WAAW,WAAW,SAAS,EAAE,QAAQ,CAAC,CAAC;AAAA,EAClF;AACF;AAEO,IAAM,aAAa,CAAC,UAA2B;AACpD,SAAO,aAAa,YAAY,KAAK,CAAC;AACxC;AAEO,IAAM,YAAY,CAAC,UAAuB;AAC/C,SAAO,iBAAiB,KAAK,KAAK,CAAC;AACrC;AAEO,IAAM,SAAS,CAAC,UAAyB;AAC9C,SAAO,IAAI,KAAK,MAAM,iBAAiB;AACzC;AAEO,IAAM,gBAAgB,oBAAoB,IAAI,OAAO,GAAG,CAAC,OAAe,UAAU,YAAY,EAAE,GAAG,SAAS,CAAC;AAC7G,IAAM,iBAAiB,oBAAoB,IAAI,OAAO,GAAG,WAAW;AAEpE,IAAM,YAAY;AAElB,IAAM,MAAM,CAAC,QAAQ,iBAA0B;AACpD,SAAO,MAAM,QAAQ;AACvB;AAEO,IAAM,MAAM,CAAC,SAAsB,aAAoC;AAC5E,SAAO,KAAK,OAAO,EAAE,IAAI,aAAa,QAAQ,CAAC;AACjD;AAEO,IAAM,WAAW,CAAC,SAAsB,aAAoC;AACjF,SAAO,KAAK,OAAO,EAAE,SAAS,aAAa,QAAQ,CAAC;AACtD;AAEO,IAAM,QAAQ,CAAC,SAAsB,UAAiC;AAC3E,SAAO,KAAK,OAAO,EAAE,MAAM,KAAK,KAAK,CAAC;AACxC;AAEO,IAAM,QAAQ,CAAC,SAAsB,SAA4B;AACtE,SAAO,KAAK,OAAO,EAAE,MAAM,EAAE,cAAc,KAAK,CAAC;AACnD;AAEO,IAAM,UAAU,CAAC,SAAsB,UAAgC;AAC5E,SAAO,QAAQ,KAAK,OAAO,GAAG,KAAK,KAAK,CAAC;AAC3C;AAEO,IAAM,WAAW,CAAC,SAAsB,UAAgC;AAC7E,SAAO,UAAU,KAAK,OAAO,GAAG,KAAK,KAAK,CAAC,IAAI;AACjD;AAEO,IAAM,UAAU,CAAC,SAAsB,UAAgC;AAC5E,SAAO,UAAU,KAAK,OAAO,GAAG,KAAK,KAAK,CAAC,IAAI;AACjD;","names":[]}

package/dist/temporal/plain-time.d.ts

@@ -0,0 +1,49 @@
+import { Temporal } from '@js-temporal/polyfill';
+import { NominalType } from '@bessemer/cornerstone/types';
+import { Comparator } from '@bessemer/cornerstone/comparator';
+import { Result } from '@bessemer/cornerstone/result';
+import { ErrorEvent } from '@bessemer/cornerstone/error/error-event';
+import Zod from 'zod';
+import { Duration, DurationLike } from '@bessemer/cornerstone/temporal/duration';
+import { InstantLike } from '@bessemer/cornerstone/temporal/instant';
+import { TimeZoneId } from '@bessemer/cornerstone/temporal/time-zone-id';
+import { TimeUnit } from '@bessemer/cornerstone/temporal/chrono';
+export type PlainTime = Temporal.PlainTime;
+export declare const Namespace: import("@bessemer/cornerstone/resource-key").ResourceNamespace<"plain-time">;
+export type PlainTimeLiteral = NominalType<string, typeof Namespace>;
+export type PlainTimeBuilder = {
+    hour?: number;
+    minute?: number;
+    second?: number;
+    millisecond?: number;
+    microsecond?: number;
+    nanosecond?: number;
+};
+export type PlainTimeLike = PlainTime | PlainTimeLiteral | PlainTimeBuilder;
+export declare const from: (value: PlainTimeLike) => PlainTime;
+export declare const CompareBy: Comparator<PlainTime>;
+export declare const EqualBy: import("@bessemer/cornerstone/equalitor").Equalitor<Temporal.PlainTime>;
+export declare const parseString: (value: string) => Result<PlainTime, ErrorEvent>;
+export declare const fromString: (value: string) => PlainTime;
+export declare const fromDuration: (duration: DurationLike) => PlainTime;
+export declare const fromInstant: (instant: InstantLike, zone: TimeZoneId) => PlainTime;
+export declare const toLiteral: (likeValue: PlainTimeLike) => PlainTimeLiteral;
+export declare const SchemaLiteral: Zod.ZodPipe<Zod.ZodString, Zod.ZodTransform<PlainTimeLiteral, string>>;
+export declare const SchemaInstance: Zod.ZodPipe<Zod.ZodString, Zod.ZodTransform<Temporal.PlainTime, string>>;
+export declare const isPlainTime: (value: unknown) => value is PlainTime;
+export declare const now: (clock?: {
+    readonly zone: TimeZoneId;
+    instant(): import("@bessemer/cornerstone/temporal/instant").Instant;
+    withZone(zone: TimeZoneId): import("@bessemer/cornerstone/temporal/clock").Clock;
+}) => PlainTime;
+export declare const merge: (element: PlainTimeLike, builder: PlainTimeBuilder) => PlainTime;
+export declare const add: (element: PlainTimeLike, duration: DurationLike) => PlainTime;
+export declare const subtract: (element: PlainTimeLike, duration: DurationLike) => PlainTime;
+export declare const until: (element: PlainTimeLike, other: PlainTimeLike) => Duration;
+export declare const round: (element: PlainTimeLike, unit: TimeUnit) => PlainTime;
+export declare const isEqual: (element: PlainTimeLike, other: PlainTimeLike) => boolean;
+export declare const isBefore: (element: PlainTimeLike, other: PlainTimeLike) => boolean;
+export declare const isAfter: (element: PlainTimeLike, other: PlainTimeLike) => boolean;
+export declare const Midnight: Temporal.PlainTime;
+export declare const Noon: Temporal.PlainTime;
+//# sourceMappingURL=plain-time.d.ts.map

package/dist/temporal/plain-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plain-time.d.ts","sourceRoot":"","sources":["../../src/temporal/plain-time.ts"],"names":[],"mappings":"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"}

package/dist/temporal/plain-time.js

@@ -0,0 +1,111 @@
+// src/temporal/plain-time.ts
+import { Temporal } from "@js-temporal/polyfill";
+import { namespace } from "@bessemer/cornerstone/resource-key";
+import { fromComparator } from "@bessemer/cornerstone/equalitor";
+import { failure, mapResult, success } from "@bessemer/cornerstone/result";
+import { invalidValue, unpackResult } from "@bessemer/cornerstone/error/error-event";
+import { isError } from "@bessemer/cornerstone/error/error";
+import { structuredTransform } from "@bessemer/cornerstone/zod-util";
+import Zod from "zod";
+import { Default as DefaultClock } from "@bessemer/cornerstone/temporal/clock";
+import { from as _fromDuration } from "@bessemer/cornerstone/temporal/duration";
+import { from as _fromInstant } from "@bessemer/cornerstone/temporal/instant";
+import { isString } from "@bessemer/cornerstone/string";
+var Namespace = namespace("plain-time");
+var from = (value) => {
+  if (value instanceof Temporal.PlainTime) {
+    return value;
+  }
+  if (isString(value)) {
+    return fromString(value);
+  }
+  return Temporal.PlainTime.from(value);
+};
+var CompareBy = (first, second) => Temporal.PlainTime.compare(first, second);
+var EqualBy = fromComparator(CompareBy);
+var parseString = (value) => {
+  try {
+    return success(Temporal.PlainTime.from(value));
+  } catch (e) {
+    if (!isError(e)) {
+      throw e;
+    }
+    return failure(invalidValue(value, { namespace: Namespace, message: e.message }));
+  }
+};
+var fromString = (value) => {
+  return unpackResult(parseString(value));
+};
+var fromDuration = (duration) => {
+  return Midnight.add(_fromDuration(duration));
+};
+var fromInstant = (instant, zone) => {
+  return _fromInstant(instant).toZonedDateTimeISO(zone).toPlainTime();
+};
+var toLiteral = (likeValue) => {
+  const value = from(likeValue);
+  if (value.second === 0 && value.millisecond === 0 && value.microsecond === 0 && value.nanosecond === 0) {
+    return `${value.hour.toString().padStart(2, "0")}:${value.minute.toString().padStart(2, "0")}`;
+  }
+  return value.toString();
+};
+var SchemaLiteral = structuredTransform(Zod.string(), (it) => mapResult(parseString(it), toLiteral));
+var SchemaInstance = structuredTransform(Zod.string(), parseString);
+var isPlainTime = (value) => {
+  return value instanceof Temporal.PlainTime;
+};
+var now = (clock = DefaultClock) => {
+  return fromInstant(clock.instant(), clock.zone);
+};
+var merge = (element, builder) => {
+  return from(element).with(builder);
+};
+var add = (element, duration) => {
+  return from(element).add(_fromDuration(duration));
+};
+var subtract = (element, duration) => {
+  return from(element).subtract(_fromDuration(duration));
+};
+var until = (element, other) => {
+  return from(element).until(from(other));
+};
+var round = (element, unit) => {
+  return from(element).round({ smallestUnit: unit });
+};
+var isEqual = (element, other) => {
+  return EqualBy(from(element), from(other));
+};
+var isBefore = (element, other) => {
+  return CompareBy(from(element), from(other)) < 0;
+};
+var isAfter = (element, other) => {
+  return CompareBy(from(element), from(other)) > 0;
+};
+var Midnight = from({ nanosecond: 0 });
+var Noon = from({ hour: 12 });
+export {
+  CompareBy,
+  EqualBy,
+  Midnight,
+  Namespace,
+  Noon,
+  SchemaInstance,
+  SchemaLiteral,
+  add,
+  from,
+  fromDuration,
+  fromInstant,
+  fromString,
+  isAfter,
+  isBefore,
+  isEqual,
+  isPlainTime,
+  merge,
+  now,
+  parseString,
+  round,
+  subtract,
+  toLiteral,
+  until
+};
+//# sourceMappingURL=plain-time.js.map

package/dist/temporal/plain-time.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/temporal/plain-time.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill'\nimport { namespace } from '@bessemer/cornerstone/resource-key'\nimport { NominalType } from '@bessemer/cornerstone/types'\nimport { Comparator } from '@bessemer/cornerstone/comparator'\nimport { fromComparator } from '@bessemer/cornerstone/equalitor'\nimport { failure, mapResult, Result, success } from '@bessemer/cornerstone/result'\nimport { ErrorEvent, invalidValue, unpackResult } from '@bessemer/cornerstone/error/error-event'\nimport { isError } from '@bessemer/cornerstone/error/error'\nimport { structuredTransform } from '@bessemer/cornerstone/zod-util'\nimport Zod from 'zod'\nimport { Default as DefaultClock } from '@bessemer/cornerstone/temporal/clock'\nimport { Duration, DurationLike, from as _fromDuration } from '@bessemer/cornerstone/temporal/duration'\nimport { from as _fromInstant, InstantLike } from '@bessemer/cornerstone/temporal/instant'\nimport { TimeZoneId } from '@bessemer/cornerstone/temporal/time-zone-id'\nimport { TimeUnit } from '@bessemer/cornerstone/temporal/chrono'\nimport { isString } from '@bessemer/cornerstone/string'\n\nexport type PlainTime = Temporal.PlainTime\nexport const Namespace = namespace('plain-time')\nexport type PlainTimeLiteral = NominalType<string, typeof Namespace>\nexport type PlainTimeBuilder = {\n  hour?: number\n  minute?: number\n  second?: number\n  millisecond?: number\n  microsecond?: number\n  nanosecond?: number\n}\nexport type PlainTimeLike = PlainTime | PlainTimeLiteral | PlainTimeBuilder\n\nexport const from = (value: PlainTimeLike): PlainTime => {\n  if (value instanceof Temporal.PlainTime) {\n    return value\n  }\n  if (isString(value)) {\n    return fromString(value)\n  }\n\n  return Temporal.PlainTime.from(value)\n}\n\nexport const CompareBy: Comparator<PlainTime> = (first: PlainTime, second: PlainTime): number => Temporal.PlainTime.compare(first, second)\nexport const EqualBy = fromComparator(CompareBy)\n\nexport const parseString = (value: string): Result<PlainTime, ErrorEvent> => {\n  try {\n    return success(Temporal.PlainTime.from(value))\n  } catch (e) {\n    if (!isError(e)) {\n      throw e\n    }\n\n    return failure(invalidValue(value, { namespace: Namespace, message: e.message }))\n  }\n}\n\nexport const fromString = (value: string): PlainTime => {\n  return unpackResult(parseString(value))\n}\n\nexport const fromDuration = (duration: DurationLike): PlainTime => {\n  return Midnight.add(_fromDuration(duration))\n}\n\nexport const fromInstant = (instant: InstantLike, zone: TimeZoneId): PlainTime => {\n  return _fromInstant(instant).toZonedDateTimeISO(zone).toPlainTime()\n}\n\nexport const toLiteral = (likeValue: PlainTimeLike): PlainTimeLiteral => {\n  const value = from(likeValue)\n\n  if (value.second === 0 && value.millisecond === 0 && value.microsecond === 0 && value.nanosecond === 0) {\n    return `${value.hour.toString().padStart(2, '0')}:${value.minute.toString().padStart(2, '0')}` as PlainTimeLiteral\n  }\n\n  return value.toString() as PlainTimeLiteral\n}\n\nexport const SchemaLiteral = structuredTransform(Zod.string(), (it: string) => mapResult(parseString(it), toLiteral))\nexport const SchemaInstance = structuredTransform(Zod.string(), parseString)\n\nexport const isPlainTime = (value: unknown): value is PlainTime => {\n  return value instanceof Temporal.PlainTime\n}\n\nexport const now = (clock = DefaultClock): PlainTime => {\n  return fromInstant(clock.instant(), clock.zone)\n}\n\nexport const merge = (element: PlainTimeLike, builder: PlainTimeBuilder): PlainTime => {\n  return from(element).with(builder)\n}\n\nexport const add = (element: PlainTimeLike, duration: DurationLike): PlainTime => {\n  return from(element).add(_fromDuration(duration))\n}\n\nexport const subtract = (element: PlainTimeLike, duration: DurationLike): PlainTime => {\n  return from(element).subtract(_fromDuration(duration))\n}\n\nexport const until = (element: PlainTimeLike, other: PlainTimeLike): Duration => {\n  return from(element).until(from(other))\n}\n\nexport const round = (element: PlainTimeLike, unit: TimeUnit): PlainTime => {\n  return from(element).round({ smallestUnit: unit })\n}\n\nexport const isEqual = (element: PlainTimeLike, other: PlainTimeLike): boolean => {\n  return EqualBy(from(element), from(other))\n}\n\nexport const isBefore = (element: PlainTimeLike, other: PlainTimeLike): boolean => {\n  return CompareBy(from(element), from(other)) < 0\n}\n\nexport const isAfter = (element: PlainTimeLike, other: PlainTimeLike): boolean => {\n  return CompareBy(from(element), from(other)) > 0\n}\n\nexport const Midnight = from({ nanosecond: 0 })\nexport const Noon = from({ hour: 12 })\n"],"mappings":"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","names":[]}

package/dist/temporal/time-zone-id.d.ts

@@ -0,0 +1,12 @@
+import { Result } from '@bessemer/cornerstone/result';
+import Zod from 'zod';
+import { NominalType } from '@bessemer/cornerstone/types';
+import { ErrorEvent } from '@bessemer/cornerstone/error/error-event';
+export declare const Namespace: import("@bessemer/cornerstone/resource-key").ResourceNamespace<"time-zone-id">;
+export type TimeZoneId = NominalType<string, typeof Namespace>;
+export declare const parseString: (value: string) => Result<TimeZoneId, ErrorEvent>;
+export declare const fromString: (value: string) => TimeZoneId;
+export declare const Schema: Zod.ZodPipe<Zod.ZodString, Zod.ZodTransform<TimeZoneId, string>>;
+export declare const Utc: TimeZoneId;
+export declare const SystemDefault: TimeZoneId;
+//# sourceMappingURL=time-zone-id.d.ts.map

package/dist/temporal/time-zone-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-zone-id.d.ts","sourceRoot":"","sources":["../../src/temporal/time-zone-id.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,MAAM,EAAW,MAAM,8BAA8B,CAAA;AACvE,OAAO,GAAG,MAAM,KAAK,CAAA;AACrB,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAEzD,OAAO,EAAE,UAAU,EAA8B,MAAM,yCAAyC,CAAA;AAIhG,eAAO,MAAM,SAAS,gFAA4B,CAAA;AAClD,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,MAAM,EAAE,OAAO,SAAS,CAAC,CAAA;AAE9D,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,KAAG,MAAM,CAAC,UAAU,EAAE,UAAU,CAWxE,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,KAAG,UAE1C,CAAA;AAED,eAAO,MAAM,MAAM,kEAAiD,CAAA;AAEpE,eAAO,MAAM,GAAG,EAAY,UAAU,CAAA;AACtC,eAAO,MAAM,aAAa,EAAuD,UAAU,CAAA"}

package/dist/temporal/time-zone-id.js

@@ -0,0 +1,35 @@
+// src/temporal/time-zone-id.ts
+import { failure, success } from "@bessemer/cornerstone/result";
+import Zod from "zod";
+import { namespace } from "@bessemer/cornerstone/resource-key";
+import { invalidValue, unpackResult } from "@bessemer/cornerstone/error/error-event";
+import { isError } from "@bessemer/cornerstone/error/error";
+import { structuredTransform } from "@bessemer/cornerstone/zod-util";
+var Namespace = namespace("time-zone-id");
+var parseString = (value) => {
+  try {
+    const fmt = new Intl.DateTimeFormat(void 0, { timeZone: value });
+    return success(fmt.resolvedOptions().timeZone);
+  } catch (e) {
+    if (isError(e)) {
+      return failure(invalidValue(value, { namespace: Namespace, message: e.message }));
+    } else {
+      throw e;
+    }
+  }
+};
+var fromString = (value) => {
+  return unpackResult(parseString(value));
+};
+var Schema = structuredTransform(Zod.string(), parseString);
+var Utc = "UTC";
+var SystemDefault = Intl.DateTimeFormat().resolvedOptions().timeZone;
+export {
+  Namespace,
+  Schema,
+  SystemDefault,
+  Utc,
+  fromString,
+  parseString
+};
+//# sourceMappingURL=time-zone-id.js.map

package/dist/temporal/time-zone-id.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/temporal/time-zone-id.ts"],"sourcesContent":["import { failure, Result, success } from '@bessemer/cornerstone/result'\nimport Zod from 'zod'\nimport { NominalType } from '@bessemer/cornerstone/types'\nimport { namespace } from '@bessemer/cornerstone/resource-key'\nimport { ErrorEvent, invalidValue, unpackResult } from '@bessemer/cornerstone/error/error-event'\nimport { isError } from '@bessemer/cornerstone/error/error'\nimport { structuredTransform } from '@bessemer/cornerstone/zod-util'\n\nexport const Namespace = namespace('time-zone-id')\nexport type TimeZoneId = NominalType<string, typeof Namespace>\n\nexport const parseString = (value: string): Result<TimeZoneId, ErrorEvent> => {\n  try {\n    const fmt = new Intl.DateTimeFormat(undefined, { timeZone: value })\n    return success(fmt.resolvedOptions().timeZone as TimeZoneId)\n  } catch (e) {\n    if (isError(e)) {\n      return failure(invalidValue(value, { namespace: Namespace, message: e.message }))\n    } else {\n      throw e\n    }\n  }\n}\n\nexport const fromString = (value: string): TimeZoneId => {\n  return unpackResult(parseString(value))\n}\n\nexport const Schema = structuredTransform(Zod.string(), parseString)\n\nexport const Utc = 'UTC' as TimeZoneId\nexport const SystemDefault = Intl.DateTimeFormat().resolvedOptions().timeZone as TimeZoneId\n"],"mappings":";AAAA,SAAS,SAAiB,eAAe;AACzC,OAAO,SAAS;AAEhB,SAAS,iBAAiB;AAC1B,SAAqB,cAAc,oBAAoB;AACvD,SAAS,eAAe;AACxB,SAAS,2BAA2B;AAE7B,IAAM,YAAY,UAAU,cAAc;AAG1C,IAAM,cAAc,CAAC,UAAkD;AAC5E,MAAI;AACF,UAAM,MAAM,IAAI,KAAK,eAAe,QAAW,EAAE,UAAU,MAAM,CAAC;AAClE,WAAO,QAAQ,IAAI,gBAAgB,EAAE,QAAsB;AAAA,EAC7D,SAAS,GAAG;AACV,QAAI,QAAQ,CAAC,GAAG;AACd,aAAO,QAAQ,aAAa,OAAO,EAAE,WAAW,WAAW,SAAS,EAAE,QAAQ,CAAC,CAAC;AAAA,IAClF,OAAO;AACL,YAAM;AAAA,IACR;AAAA,EACF;AACF;AAEO,IAAM,aAAa,CAAC,UAA8B;AACvD,SAAO,aAAa,YAAY,KAAK,CAAC;AACxC;AAEO,IAAM,SAAS,oBAAoB,IAAI,OAAO,GAAG,WAAW;AAE5D,IAAM,MAAM;AACZ,IAAM,gBAAgB,KAAK,eAAe,EAAE,gBAAgB,EAAE;","names":[]}

package/dist/temporal/time-zone-offset.d.ts

@@ -0,0 +1,22 @@
+import { NominalType } from '@bessemer/cornerstone/types';
+import { Duration, DurationLike } from '@bessemer/cornerstone/temporal/duration';
+import { Result } from '@bessemer/cornerstone/result';
+import Zod from 'zod';
+import { ErrorEvent } from '@bessemer/cornerstone/error/error-event';
+import { Instant } from '@bessemer/cornerstone/temporal/instant';
+import { TimeZoneId } from '@bessemer/cornerstone/temporal/time-zone-id';
+export declare const Namespace: import("@bessemer/cornerstone/resource-key").ResourceNamespace<"time-zone-offset">;
+export type TimeZoneOffset = NominalType<number, typeof Namespace>;
+export declare const parseMinutes: (value: number) => Result<TimeZoneOffset, ErrorEvent>;
+export declare const parseDuration: (value: Duration) => Result<TimeZoneOffset, ErrorEvent>;
+export declare const fromMinutes: (value: number) => TimeZoneOffset;
+export declare const fromDuration: (value: DurationLike) => TimeZoneOffset;
+export declare const fromTimeZone: (timeZone: TimeZoneId, instant: Instant) => TimeZoneOffset;
+export declare const parseString: (value: string) => Result<TimeZoneOffset, ErrorEvent>;
+export declare const fromString: (value: string) => TimeZoneOffset;
+export declare const Schema: Zod.ZodUnion<readonly [Zod.ZodPipe<Zod.ZodNumber, Zod.ZodTransform<TimeZoneOffset, number>>, Zod.ZodPipe<Zod.ZodString, Zod.ZodTransform<TimeZoneOffset, string>>]>;
+export declare const toDuration: (offset: TimeZoneOffset) => Duration;
+export declare const toMilliseconds: (offset: TimeZoneOffset) => number;
+export declare const toString: (offset: TimeZoneOffset) => string;
+export declare const Utc: TimeZoneOffset;
+//# sourceMappingURL=time-zone-offset.d.ts.map

package/dist/temporal/time-zone-offset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-zone-offset.d.ts","sourceRoot":"","sources":["../../src/temporal/time-zone-offset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AACzD,OAAO,EACL,QAAQ,EACR,YAAY,EAQb,MAAM,yCAAyC,CAAA;AAEhD,OAAO,EAAW,MAAM,EAAW,MAAM,8BAA8B,CAAA;AACvE,OAAO,GAAG,MAAM,KAAK,CAAA;AACrB,OAAO,EAAE,UAAU,EAA8B,MAAM,yCAAyC,CAAA;AAGhG,OAAO,EAAE,OAAO,EAAE,MAAM,wCAAwC,CAAA;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,6CAA6C,CAAA;AAExE,eAAO,MAAM,SAAS,oFAAgC,CAAA;AACtD,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,MAAM,EAAE,OAAO,SAAS,CAAC,CAAA;AAIlE,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,KAAG,MAAM,CAAC,cAAc,EAAE,UAAU,CAU7E,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,OAAO,QAAQ,KAAG,MAAM,CAAC,cAAc,EAAE,UAAU,CAEhF,CAAA;AAED,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,KAAG,cAE3C,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,OAAO,YAAY,KAAG,cAElD,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,UAAU,UAAU,EAAE,SAAS,OAAO,KAAG,cAsBrE,CAAA;AAGD,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,KAAG,MAAM,CAAC,cAAc,EAAE,UAAU,CAyE5E,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,KAAG,cAE1C,CAAA;AAED,eAAO,MAAM,MAAM,qKAA+G,CAAA;AAElI,eAAO,MAAM,UAAU,GAAI,QAAQ,cAAc,KAAG,QAEnD,CAAA;AAED,eAAO,MAAM,cAAc,GAAI,QAAQ,cAAc,KAAG,MAEvD,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,QAAQ,cAAc,KAAG,MASjD,CAAA;AAED,eAAO,MAAM,GAAG,EAAQ,cAAc,CAAA"}