@atproto/syntax 0.5.4 → 0.6.0-next.0

package/dist/datetime.js

@@ -1,32 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidDatetimeError = void 0;
-exports.assertAtprotoDate = assertAtprotoDate;
-exports.asAtprotoDate = asAtprotoDate;
-exports.isAtprotoDate = isAtprotoDate;
-exports.ifAtprotoDate = ifAtprotoDate;
-exports.assertDatetimeString = assertDatetimeString;
-exports.ensureValidDatetime = assertDatetimeString;
-exports.asDatetimeString = asDatetimeString;
-exports.isDatetimeString = isDatetimeString;
-exports.isValidDatetime = isDatetimeString;
-exports.ifDatetimeString = ifDatetimeString;
-exports.currentDatetimeString = currentDatetimeString;
-exports.toDatetimeString = toDatetimeString;
-exports.normalizeDatetime = normalizeDatetime;
-exports.normalizeDatetimeAlways = normalizeDatetimeAlways;
 /**
  * Indicates a date or string is not a valid representation of a datetime
  * according to the atproto
  * {@link https://atproto.com/specs/lexicon#datetime specification}.
  */
-class InvalidDatetimeError extends Error {
+export class InvalidDatetimeError extends Error {
 }
-exports.InvalidDatetimeError = InvalidDatetimeError;
 /**
  * @see {@link AtprotoDate}
  */
-function assertAtprotoDate(date) {
+export function assertAtprotoDate(date) {
     const res = parseDate(date);
     if (!res.success) {
         throw new InvalidDatetimeError(res.message);
@@ -35,20 +17,20 @@ function assertAtprotoDate(date) {
 /**
  * @see {@link AtprotoDate}
  */
-function asAtprotoDate(date) {
+export function asAtprotoDate(date) {
     assertAtprotoDate(date);
     return date;
 }
 /**
  * @see {@link AtprotoDate}
  */
-function isAtprotoDate(date) {
+export function isAtprotoDate(date) {
     return parseDate(date).success;
 }
 /**
  * @see {@link AtprotoDate}
  */
-function ifAtprotoDate(date) {
+export function ifAtprotoDate(date) {
     return isAtprotoDate(date) ? date : undefined;
 }
 /**
@@ -58,7 +40,7 @@ function ifAtprotoDate(date) {
  * @throws InvalidDatetimeError if the input string does not meet the atproto 'datetime' format requirements.
  * @see {@link DatetimeString}
  */
-function assertDatetimeString(input) {
+export function assertDatetimeString(input) {
     const result = parseString(input);
     if (!result.success) {
         throw new InvalidDatetimeError(result.message);
@@ -71,7 +53,7 @@ function assertDatetimeString(input) {
  * @throws InvalidDatetimeError if the input string does not meet the atproto 'datetime' format requirements.
  * @see {@link DatetimeString}
  */
-function asDatetimeString(input) {
+export function asDatetimeString(input) {
     assertDatetimeString(input);
     return input;
 }
@@ -80,7 +62,7 @@ function asDatetimeString(input) {
  *
  * @see {@link DatetimeString}
  */
-function isDatetimeString(input) {
+export function isDatetimeString(input) {
     return parseString(input).success;
 }
 /**
@@ -89,7 +71,7 @@ function isDatetimeString(input) {
  *
  * @see {@link DatetimeString}
  */
-function ifDatetimeString(input) {
+export function ifDatetimeString(input) {
     return isDatetimeString(input) ? input : undefined;
 }
 /**
@@ -97,7 +79,7 @@ function ifDatetimeString(input) {
  *
  * @see {@link DatetimeString}
  */
-function currentDatetimeString() {
+export function currentDatetimeString() {
     return toDatetimeString(new Date());
 }
 /**
@@ -109,7 +91,7 @@ function currentDatetimeString() {
  * @throws InvalidDatetimeError if the input date is not a valid atproto datetime (eg, it is too far in the future or past, or it normalizes to a negative year).
  * @see {@link DatetimeString}
  */
-function toDatetimeString(date) {
+export function toDatetimeString(date) {
     return asAtprotoDate(date).toISOString();
 }
 /**
@@ -130,7 +112,7 @@ function toDatetimeString(date) {
  * @returns ISODatetimeString - a valid atproto datetime with millisecond precision (3 sub-second digits) and UTC timezone with trailing 'Z' syntax.
  * @throws InvalidDatetimeError - if the input string could not be parsed as a datetime, even with permissive parsing.
  */
-function normalizeDatetime(dtStr) {
+export function normalizeDatetime(dtStr) {
     if (
     // Explicit timezone offset
     /[+-]\d\d:?\d\d/.test(dtStr) ||
@@ -179,7 +161,7 @@ function normalizeDatetime(dtStr) {
  *
  * @see {@link normalizeDatetime}
  */
-function normalizeDatetimeAlways(dtStr) {
+export function normalizeDatetimeAlways(dtStr) {
     try {
         return normalizeDatetime(dtStr);
     }
@@ -187,6 +169,8 @@ function normalizeDatetimeAlways(dtStr) {
         return '1970-01-01T00:00:00.000Z';
     }
 }
+// Legacy exports (should we deprecate these ?)
+export { assertDatetimeString as ensureValidDatetime, isDatetimeString as isValidDatetime, };
 const failure = (m) => ({ success: false, message: m });
 const success = (v) => ({ success: true, value: v });
 /**

package/dist/datetime.js.map

@@ -1 +1 @@
-{"version":3,"file":"datetime.js","sourceRoot":"","sources":["../src/datetime.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Indicates a date or string is not a valid representation of a datetime\n * according to the atproto\n * {@link https://atproto.com/specs/lexicon#datetime specification}.\n */\nexport class InvalidDatetimeError extends Error {}\n\n/**\n * A subset of {@link DatetimeString} that represent valid datetime strings with\n * the format: `YYYY-MM-DDTHH:mm:ss.sssZ`, as returned by `Date.toISOString()\n * for dates between the years 0000 and 9999.\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString}\n */\nexport type ISODatetimeString =\n  // @TODO Switch to branded types for more accurate type safety.\n  `${string}-${string}-${string}T${string}:${string}:${string}.${string}Z`\n\n/**\n * Represents a {@link Date} that can be safely stringified into a valid atproto\n * {@link DatetimeString} using the {@link Date.toISOString toISOString()}\n * method.\n */\nexport interface AtprotoDate extends Date {\n  toISOString(): ISODatetimeString\n}\n\n/**\n * @see {@link AtprotoDate}\n */\nexport function assertAtprotoDate(date: Date): asserts date is AtprotoDate {\n  const res = parseDate(date)\n  if (!res.success) {\n    throw new InvalidDatetimeError(res.message)\n  }\n}\n\n/**\n * @see {@link AtprotoDate}\n */\nexport function asAtprotoDate(date: Date): AtprotoDate {\n  assertAtprotoDate(date)\n  return date\n}\n\n/**\n * @see {@link AtprotoDate}\n */\nexport function isAtprotoDate(date: Date): date is AtprotoDate {\n  return parseDate(date).success\n}\n\n/**\n * @see {@link AtprotoDate}\n */\nexport function ifAtprotoDate(date: Date): AtprotoDate | undefined {\n  return isAtprotoDate(date) ? date : undefined\n}\n\n/**\n * Datetime strings in atproto data structures and API calls should meet the\n * {@link https://ijmacd.github.io/rfc3339-iso8601/ intersecting} requirements\n * of the RFC 3339, ISO 8601, and WHATWG HTML datetime standards.\n *\n * @note This literal template type is not accurate enough to ensure that a\n * string is a valid atproto datetime. The {@link DatetimeString} validation\n * functions ({@link assertDatetimeString}, {@link isDatetimeString}, etc)\n * should be used to validate that a string meets the atproto datetime\n * requirements, and the {@link toDatetimeString} function should be used to\n * convert a {@link Date} object into a valid {@link DatetimeString} string.\n *\n * @example \"2024-01-15T12:30:00Z\"\n * @example \"2024-01-15T12:30:00.000Z\"\n * @example \"2024-01-15T12:30:00+00:00\"\n * @example \"2024-01-15T11:30:00-01:00\"\n * @see {@link https://atproto.com/specs/lexicon#datetime atproto Lexicon datetime format}\n * @see {@link https://www.rfc-editor.org/rfc/rfc3339 RFC 3339}\n * @see {@link https://www.iso.org/iso-8601-date-and-time-format.html ISO 8601}\n */\nexport type DatetimeString =\n  // @TODO Switch to branded types for more accurate type safety?\n  | `${string}-${string}-${string}T${string}:${string}:${string}Z`\n  | `${string}-${string}-${string}T${string}:${string}:${string}${'+' | '-'}${string}:${string}`\n\n/**\n * Validates that a string is a valid {@link DatetimeString} format string,\n * throwing an error if it is not.\n *\n * @throws InvalidDatetimeError if the input string does not meet the atproto 'datetime' format requirements.\n * @see {@link DatetimeString}\n */\nexport function assertDatetimeString<I>(\n  input: I,\n): asserts input is I & DatetimeString {\n  const result = parseString(input)\n  if (!result.success) {\n    throw new InvalidDatetimeError(result.message)\n  }\n}\n\n/**\n * Casts a string to a {@link DatetimeString} if it is a valid datetime format\n * string, throwing an error if it is not.\n *\n * @throws InvalidDatetimeError if the input string does not meet the atproto 'datetime' format requirements.\n * @see {@link DatetimeString}\n */\nexport function asDatetimeString<I>(input: I): I & DatetimeString {\n  assertDatetimeString(input)\n  return input\n}\n\n/**\n * Checks if a string is a valid {@link DatetimeString} format string.\n *\n * @see {@link DatetimeString}\n */\nexport function isDatetimeString<I>(input: I): input is I & DatetimeString {\n  return parseString(input).success\n}\n\n/**\n * Returns the input if it is a valid {@link DatetimeString} format string, or\n * `undefined` if it is not.\n *\n * @see {@link DatetimeString}\n */\nexport function ifDatetimeString<I>(\n  input: I,\n): undefined | (I & DatetimeString) {\n  return isDatetimeString(input) ? input : undefined\n}\n\n/**\n * Returns the current date and time as a {@link DatetimeString}.\n *\n * @see {@link DatetimeString}\n */\nexport function currentDatetimeString(): DatetimeString {\n  return toDatetimeString(new Date())\n}\n\n/**\n * Converts any {@link Date} into a {@link DatetimeString} if possible, throwing\n * an error if the date is not a valid atproto datetime.\n *\n * This is short-hand for `asAtprotoDate(date).toISOString()`.\n *\n * @throws InvalidDatetimeError if the input date is not a valid atproto datetime (eg, it is too far in the future or past, or it normalizes to a negative year).\n * @see {@link DatetimeString}\n */\nexport function toDatetimeString(date: Date): DatetimeString {\n  return asAtprotoDate(date).toISOString()\n}\n\n/**\n * Takes a flexible datetime string and normalizes its representation.\n *\n * This function will work with any valid value that can be parsed as a date. It\n * *additionally* is more flexible about accepting datetimes that are missing\n * timezone information, and normalizing them to a valid atproto datetime.\n *\n * One use-case is a consistent, sortable string. Another is to work with older\n * invalid createdAt datetimes.\n *\n * @note This function might return different normalized strings for the same\n * input depending on the timezone of the machine it is run on, since it will\n * attempt to parse the input \"as is\" if it fails to parse with an explicit\n * timezone.\n *\n * @returns ISODatetimeString - a valid atproto datetime with millisecond precision (3 sub-second digits) and UTC timezone with trailing 'Z' syntax.\n * @throws InvalidDatetimeError - if the input string could not be parsed as a datetime, even with permissive parsing.\n */\nexport function normalizeDatetime(dtStr: string): ISODatetimeString {\n  if (\n    // Explicit timezone offset\n    /[+-]\\d\\d:?\\d\\d/.test(dtStr) ||\n    // 'Z' timezone designator\n    /\\dZ\\b/.test(dtStr) ||\n    // Timezone abbreviation (eg. \"EST\", \"PST\", \"UTC\", \"GMT\", etc), as in:\n    // > Tue Mar 17 2026 16:38:44 PST (Pacific Standard Time)\n    /\\b[A-Z]{3,4}\\b/.test(dtStr)\n  ) {\n    // Since we do have a timezone designator, we can try parsing \"as is\" and\n    // should get consistent results regardless of local timezone.\n\n    // @NOTE NodeJS will reject dates with an un-recognized timezone designator\n    // (like \"AFT\"), even if we add a well-known timezone abbreviation like\n    // \"UTC\" or \"Z\".\n    const date = new Date(dtStr)\n    if (isAtprotoDate(date)) {\n      return date.toISOString()\n    }\n  } else {\n    // If there is no timezone information, try parsing as UTC using two\n    // different syntaxes, falling back to parsing \"as is\".\n\n    const dateZ = new Date(`${dtStr}Z`)\n    if (isAtprotoDate(dateZ)) {\n      return dateZ.toISOString()\n    }\n\n    const dateUTC = new Date(`${dtStr} UTC`)\n    if (isAtprotoDate(dateUTC)) {\n      return dateUTC.toISOString()\n    }\n\n    // Despite our best efforts to parse as a consistent value, appending \"Z\" or\n    // \" UTC\" did not work, so we will try parsing \"as is\", which may yield\n    // different results depending on the local timezone of the machine.\n    const date = new Date(dtStr)\n    if (isAtprotoDate(date)) {\n      return date.toISOString()\n    }\n  }\n\n  throw new InvalidDatetimeError(\n    'datetime did not parse as any timestamp format',\n  )\n}\n\n/**\n * Variant of {@link normalizeDatetime} which always returns a valid datetime\n * string.\n *\n * If a {@link InvalidDatetimeError} is encountered, returns the UNIX epoch time\n * as a UTC datetime (`1970-01-01T00:00:00.000Z`).\n *\n * @see {@link normalizeDatetime}\n */\nexport function normalizeDatetimeAlways(dtStr: string): ISODatetimeString {\n  try {\n    return normalizeDatetime(dtStr)\n  } catch (err) {\n    return '1970-01-01T00:00:00.000Z'\n  }\n}\n\n// Legacy exports (should we deprecate these ?)\nexport {\n  assertDatetimeString as ensureValidDatetime,\n  isDatetimeString as isValidDatetime,\n}\n\n// -----------------------------------------------------------------------------\n// ------------------------- Internal validation logic -------------------------\n// -----------------------------------------------------------------------------\n\n// Validation utils that allow avoiding try/catch for control flow (performance\n// optimization). Other syntax formats should also use this pattern to avoid\n// try/catch in their validation logic, at which point these utils can be moved\n// to a common internal utils.\ntype FailureResult = { success: false; message: string }\nconst failure = (m: string): FailureResult => ({ success: false, message: m })\ntype SuccessResult<V> = { success: true; value: V }\nconst success = <V>(v: V): SuccessResult<V> => ({ success: true, value: v })\ntype Result<V> = FailureResult | SuccessResult<V>\n\n/**\n * @see {@link https://www.rfc-editor.org/rfc/rfc3339#section-5.6 Internet Date/Time Format}\n *\n * @example\n * ```abnf\n * date-fullyear   = 4DIGIT\n * date-month      = 2DIGIT  ; 01-12\n * date-mday       = 2DIGIT  ; 01-28, 01-29, 01-30, 01-31 based on\n *                           ; month/year\n * time-hour       = 2DIGIT  ; 00-23\n * time-minute     = 2DIGIT  ; 00-59\n * time-second     = 2DIGIT  ; 00-58, 00-59, 00-60 based on leap second\n *                           ; rules\n * time-secfrac    = \".\" 1*DIGIT\n * time-numoffset  = (\"+\" / \"-\") time-hour \":\" time-minute\n * time-offset     = \"Z\" / time-numoffset\n * partial-time    = time-hour \":\" time-minute \":\" time-second\n *                   [time-secfrac]\n * full-date       = date-fullyear \"-\" date-month \"-\" date-mday\n * full-time       = partial-time time-offset\n * date-time       = full-date \"T\" full-time\n * ```\n */\nconst DATETIME_REGEX =\n  /^(?<full_year>[0-9]{4})-(?<date_month>0[1-9]|1[012])-(?<date_mday>[0-2][0-9]|3[01])T(?<time_hour>[0-1][0-9]|2[0-3]):(?<time_minute>[0-5][0-9]):(?<time_second>[0-5][0-9]|60)(?<time_secfrac>\\.[0-9]+)?(?<time_offset>Z|(?<time_numoffset>[+-](?:[0-1][0-9]|2[0-3]):[0-5][0-9]))$/\n\n/**\n * Validates that the input is a datetime string according to atproto Lexicon\n * rules, and parses it into a Date object.\n */\nfunction parseString(input: unknown): Result<AtprotoDate> {\n  // @NOTE Performing cheap tests first\n  if (typeof input !== 'string') {\n    return failure('datetime must be a string')\n  }\n  if (input.length > 64) {\n    return failure('datetime is too long (64 chars max)')\n  }\n  if (input.endsWith('-00:00')) {\n    return failure('datetime can not use \"-00:00\" for UTC timezone')\n  }\n  if (!DATETIME_REGEX.test(input)) {\n    return failure(\n      \"datetime is not in a valid format (must match RFC 3339 & ISO 8601 with 'Z' or ±hh:mm timezone)\",\n    )\n  }\n\n  // must parse as ISO 8601; this also verifies semantics like leap seconds and\n  // correct number of days in month, which the regex does not check for\n  const date = new Date(input)\n\n  return parseDate(date)\n}\n\n/**\n * Ensures that a Date object represents a valid datetime according to atproto\n * Lexicon rules. This ensures that `date.toISOString()` will produce a valid\n * datetime string that can be used where {@link DatetimeString} is expected.\n */\nfunction parseDate(date: Date): Result<AtprotoDate> {\n  const fullYear = date.getUTCFullYear()\n  // Ensures that the date is valid. We could check isNaN(date.getTime()) here\n  // but since we'll check the year anyway, we just use that for the validity\n  // check since an invalid date will have NaN year.\n  if (Number.isNaN(fullYear)) {\n    return failure('datetime did not parse as ISO 8601')\n  }\n  // Ensure that the ISO string representation does not start with ±YYYYYY\n  if (fullYear < 0) {\n    return failure('datetime normalized to a negative time')\n  }\n  if (fullYear > 9999) {\n    return failure('datetime year is too far in the future')\n  }\n  return success(date as AtprotoDate)\n}\n"]}
+{"version":3,"file":"datetime.js","sourceRoot":"","sources":["../src/datetime.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Indicates a date or string is not a valid representation of a datetime\n * according to the atproto\n * {@link https://atproto.com/specs/lexicon#datetime specification}.\n */\nexport class InvalidDatetimeError extends Error {}\n\n/**\n * A subset of {@link DatetimeString} that represent valid datetime strings with\n * the format: `YYYY-MM-DDTHH:mm:ss.sssZ`, as returned by `Date.toISOString()\n * for dates between the years 0000 and 9999.\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString}\n */\nexport type ISODatetimeString =\n  // @TODO Switch to branded types for more accurate type safety.\n  `${string}-${string}-${string}T${string}:${string}:${string}.${string}Z`\n\n/**\n * Represents a {@link Date} that can be safely stringified into a valid atproto\n * {@link DatetimeString} using the {@link Date.toISOString toISOString()}\n * method.\n */\nexport interface AtprotoDate extends Date {\n  toISOString(): ISODatetimeString\n}\n\n/**\n * @see {@link AtprotoDate}\n */\nexport function assertAtprotoDate(date: Date): asserts date is AtprotoDate {\n  const res = parseDate(date)\n  if (!res.success) {\n    throw new InvalidDatetimeError(res.message)\n  }\n}\n\n/**\n * @see {@link AtprotoDate}\n */\nexport function asAtprotoDate(date: Date): AtprotoDate {\n  assertAtprotoDate(date)\n  return date\n}\n\n/**\n * @see {@link AtprotoDate}\n */\nexport function isAtprotoDate(date: Date): date is AtprotoDate {\n  return parseDate(date).success\n}\n\n/**\n * @see {@link AtprotoDate}\n */\nexport function ifAtprotoDate(date: Date): AtprotoDate | undefined {\n  return isAtprotoDate(date) ? date : undefined\n}\n\n/**\n * Datetime strings in atproto data structures and API calls should meet the\n * {@link https://ijmacd.github.io/rfc3339-iso8601/ intersecting} requirements\n * of the RFC 3339, ISO 8601, and WHATWG HTML datetime standards.\n *\n * @note This literal template type is not accurate enough to ensure that a\n * string is a valid atproto datetime. The {@link DatetimeString} validation\n * functions ({@link assertDatetimeString}, {@link isDatetimeString}, etc)\n * should be used to validate that a string meets the atproto datetime\n * requirements, and the {@link toDatetimeString} function should be used to\n * convert a {@link Date} object into a valid {@link DatetimeString} string.\n *\n * @example \"2024-01-15T12:30:00Z\"\n * @example \"2024-01-15T12:30:00.000Z\"\n * @example \"2024-01-15T12:30:00+00:00\"\n * @example \"2024-01-15T11:30:00-01:00\"\n * @see {@link https://atproto.com/specs/lexicon#datetime atproto Lexicon datetime format}\n * @see {@link https://www.rfc-editor.org/rfc/rfc3339 RFC 3339}\n * @see {@link https://www.iso.org/iso-8601-date-and-time-format.html ISO 8601}\n */\nexport type DatetimeString =\n  // @TODO Switch to branded types for more accurate type safety?\n  | `${string}-${string}-${string}T${string}:${string}:${string}Z`\n  | `${string}-${string}-${string}T${string}:${string}:${string}${'+' | '-'}${string}:${string}`\n\n/**\n * Validates that a string is a valid {@link DatetimeString} format string,\n * throwing an error if it is not.\n *\n * @throws InvalidDatetimeError if the input string does not meet the atproto 'datetime' format requirements.\n * @see {@link DatetimeString}\n */\nexport function assertDatetimeString<I>(\n  input: I,\n): asserts input is I & DatetimeString {\n  const result = parseString(input)\n  if (!result.success) {\n    throw new InvalidDatetimeError(result.message)\n  }\n}\n\n/**\n * Casts a string to a {@link DatetimeString} if it is a valid datetime format\n * string, throwing an error if it is not.\n *\n * @throws InvalidDatetimeError if the input string does not meet the atproto 'datetime' format requirements.\n * @see {@link DatetimeString}\n */\nexport function asDatetimeString<I>(input: I): I & DatetimeString {\n  assertDatetimeString(input)\n  return input\n}\n\n/**\n * Checks if a string is a valid {@link DatetimeString} format string.\n *\n * @see {@link DatetimeString}\n */\nexport function isDatetimeString<I>(input: I): input is I & DatetimeString {\n  return parseString(input).success\n}\n\n/**\n * Returns the input if it is a valid {@link DatetimeString} format string, or\n * `undefined` if it is not.\n *\n * @see {@link DatetimeString}\n */\nexport function ifDatetimeString<I>(\n  input: I,\n): undefined | (I & DatetimeString) {\n  return isDatetimeString(input) ? input : undefined\n}\n\n/**\n * Returns the current date and time as a {@link DatetimeString}.\n *\n * @see {@link DatetimeString}\n */\nexport function currentDatetimeString(): DatetimeString {\n  return toDatetimeString(new Date())\n}\n\n/**\n * Converts any {@link Date} into a {@link DatetimeString} if possible, throwing\n * an error if the date is not a valid atproto datetime.\n *\n * This is short-hand for `asAtprotoDate(date).toISOString()`.\n *\n * @throws InvalidDatetimeError if the input date is not a valid atproto datetime (eg, it is too far in the future or past, or it normalizes to a negative year).\n * @see {@link DatetimeString}\n */\nexport function toDatetimeString(date: Date): DatetimeString {\n  return asAtprotoDate(date).toISOString()\n}\n\n/**\n * Takes a flexible datetime string and normalizes its representation.\n *\n * This function will work with any valid value that can be parsed as a date. It\n * *additionally* is more flexible about accepting datetimes that are missing\n * timezone information, and normalizing them to a valid atproto datetime.\n *\n * One use-case is a consistent, sortable string. Another is to work with older\n * invalid createdAt datetimes.\n *\n * @note This function might return different normalized strings for the same\n * input depending on the timezone of the machine it is run on, since it will\n * attempt to parse the input \"as is\" if it fails to parse with an explicit\n * timezone.\n *\n * @returns ISODatetimeString - a valid atproto datetime with millisecond precision (3 sub-second digits) and UTC timezone with trailing 'Z' syntax.\n * @throws InvalidDatetimeError - if the input string could not be parsed as a datetime, even with permissive parsing.\n */\nexport function normalizeDatetime(dtStr: string): ISODatetimeString {\n  if (\n    // Explicit timezone offset\n    /[+-]\\d\\d:?\\d\\d/.test(dtStr) ||\n    // 'Z' timezone designator\n    /\\dZ\\b/.test(dtStr) ||\n    // Timezone abbreviation (eg. \"EST\", \"PST\", \"UTC\", \"GMT\", etc), as in:\n    // > Tue Mar 17 2026 16:38:44 PST (Pacific Standard Time)\n    /\\b[A-Z]{3,4}\\b/.test(dtStr)\n  ) {\n    // Since we do have a timezone designator, we can try parsing \"as is\" and\n    // should get consistent results regardless of local timezone.\n\n    // @NOTE NodeJS will reject dates with an un-recognized timezone designator\n    // (like \"AFT\"), even if we add a well-known timezone abbreviation like\n    // \"UTC\" or \"Z\".\n    const date = new Date(dtStr)\n    if (isAtprotoDate(date)) {\n      return date.toISOString()\n    }\n  } else {\n    // If there is no timezone information, try parsing as UTC using two\n    // different syntaxes, falling back to parsing \"as is\".\n\n    const dateZ = new Date(`${dtStr}Z`)\n    if (isAtprotoDate(dateZ)) {\n      return dateZ.toISOString()\n    }\n\n    const dateUTC = new Date(`${dtStr} UTC`)\n    if (isAtprotoDate(dateUTC)) {\n      return dateUTC.toISOString()\n    }\n\n    // Despite our best efforts to parse as a consistent value, appending \"Z\" or\n    // \" UTC\" did not work, so we will try parsing \"as is\", which may yield\n    // different results depending on the local timezone of the machine.\n    const date = new Date(dtStr)\n    if (isAtprotoDate(date)) {\n      return date.toISOString()\n    }\n  }\n\n  throw new InvalidDatetimeError(\n    'datetime did not parse as any timestamp format',\n  )\n}\n\n/**\n * Variant of {@link normalizeDatetime} which always returns a valid datetime\n * string.\n *\n * If a {@link InvalidDatetimeError} is encountered, returns the UNIX epoch time\n * as a UTC datetime (`1970-01-01T00:00:00.000Z`).\n *\n * @see {@link normalizeDatetime}\n */\nexport function normalizeDatetimeAlways(dtStr: string): ISODatetimeString {\n  try {\n    return normalizeDatetime(dtStr)\n  } catch (err) {\n    return '1970-01-01T00:00:00.000Z'\n  }\n}\n\n// Legacy exports (should we deprecate these ?)\nexport {\n  assertDatetimeString as ensureValidDatetime,\n  isDatetimeString as isValidDatetime,\n}\n\n// -----------------------------------------------------------------------------\n// ------------------------- Internal validation logic -------------------------\n// -----------------------------------------------------------------------------\n\n// Validation utils that allow avoiding try/catch for control flow (performance\n// optimization). Other syntax formats should also use this pattern to avoid\n// try/catch in their validation logic, at which point these utils can be moved\n// to a common internal utils.\ntype FailureResult = { success: false; message: string }\nconst failure = (m: string): FailureResult => ({ success: false, message: m })\ntype SuccessResult<V> = { success: true; value: V }\nconst success = <V>(v: V): SuccessResult<V> => ({ success: true, value: v })\ntype Result<V> = FailureResult | SuccessResult<V>\n\n/**\n * @see {@link https://www.rfc-editor.org/rfc/rfc3339#section-5.6 Internet Date/Time Format}\n *\n * @example\n * ```abnf\n * date-fullyear   = 4DIGIT\n * date-month      = 2DIGIT  ; 01-12\n * date-mday       = 2DIGIT  ; 01-28, 01-29, 01-30, 01-31 based on\n *                           ; month/year\n * time-hour       = 2DIGIT  ; 00-23\n * time-minute     = 2DIGIT  ; 00-59\n * time-second     = 2DIGIT  ; 00-58, 00-59, 00-60 based on leap second\n *                           ; rules\n * time-secfrac    = \".\" 1*DIGIT\n * time-numoffset  = (\"+\" / \"-\") time-hour \":\" time-minute\n * time-offset     = \"Z\" / time-numoffset\n * partial-time    = time-hour \":\" time-minute \":\" time-second\n *                   [time-secfrac]\n * full-date       = date-fullyear \"-\" date-month \"-\" date-mday\n * full-time       = partial-time time-offset\n * date-time       = full-date \"T\" full-time\n * ```\n */\nconst DATETIME_REGEX =\n  /^(?<full_year>[0-9]{4})-(?<date_month>0[1-9]|1[012])-(?<date_mday>[0-2][0-9]|3[01])T(?<time_hour>[0-1][0-9]|2[0-3]):(?<time_minute>[0-5][0-9]):(?<time_second>[0-5][0-9]|60)(?<time_secfrac>\\.[0-9]+)?(?<time_offset>Z|(?<time_numoffset>[+-](?:[0-1][0-9]|2[0-3]):[0-5][0-9]))$/\n\n/**\n * Validates that the input is a datetime string according to atproto Lexicon\n * rules, and parses it into a Date object.\n */\nfunction parseString(input: unknown): Result<AtprotoDate> {\n  // @NOTE Performing cheap tests first\n  if (typeof input !== 'string') {\n    return failure('datetime must be a string')\n  }\n  if (input.length > 64) {\n    return failure('datetime is too long (64 chars max)')\n  }\n  if (input.endsWith('-00:00')) {\n    return failure('datetime can not use \"-00:00\" for UTC timezone')\n  }\n  if (!DATETIME_REGEX.test(input)) {\n    return failure(\n      \"datetime is not in a valid format (must match RFC 3339 & ISO 8601 with 'Z' or ±hh:mm timezone)\",\n    )\n  }\n\n  // must parse as ISO 8601; this also verifies semantics like leap seconds and\n  // correct number of days in month, which the regex does not check for\n  const date = new Date(input)\n\n  return parseDate(date)\n}\n\n/**\n * Ensures that a Date object represents a valid datetime according to atproto\n * Lexicon rules. This ensures that `date.toISOString()` will produce a valid\n * datetime string that can be used where {@link DatetimeString} is expected.\n */\nfunction parseDate(date: Date): Result<AtprotoDate> {\n  const fullYear = date.getUTCFullYear()\n  // Ensures that the date is valid. We could check isNaN(date.getTime()) here\n  // but since we'll check the year anyway, we just use that for the validity\n  // check since an invalid date will have NaN year.\n  if (Number.isNaN(fullYear)) {\n    return failure('datetime did not parse as ISO 8601')\n  }\n  // Ensure that the ISO string representation does not start with ±YYYYYY\n  if (fullYear < 0) {\n    return failure('datetime normalized to a negative time')\n  }\n  if (fullYear > 9999) {\n    return failure('datetime year is too far in the future')\n  }\n  return success(date as AtprotoDate)\n}\n"]}

package/dist/did.js

@@ -1,4 +1,3 @@
-"use strict";
 // Human-readable constraints:
 //   - valid W3C DID (https://www.w3.org/TR/did-core/#did-syntax)
 //      - entire URI is ASCII: [a-zA-Z0-9._:%-]
@@ -12,12 +11,7 @@
 //   - in current atproto, only allowing did:plc and did:web. But not *forcing* this at lexicon layer
 //   - hard length limit of 8KBytes
 //   - not going to validate "percent encoding" here
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidDidError = void 0;
-exports.ensureValidDid = ensureValidDid;
-exports.ensureValidDidRegex = ensureValidDidRegex;
-exports.isValidDid = isValidDid;
-function ensureValidDid(input) {
+export function ensureValidDid(input) {
     if (!input.startsWith('did:')) {
         throw new InvalidDidError('DID requires "did:" prefix');
     }
@@ -40,7 +34,7 @@ function ensureValidDid(input) {
     }
 }
 const DID_REGEX = /^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$/;
-function ensureValidDidRegex(input) {
+export function ensureValidDidRegex(input) {
     // simple regex to enforce most constraints via just regex and length.
     // hand wrote this regex based on above constraints
     if (!DID_REGEX.test(input)) {
@@ -50,10 +44,9 @@ function ensureValidDidRegex(input) {
         throw new InvalidDidError('DID is too long (2048 chars max)');
     }
 }
-function isValidDid(input) {
+export function isValidDid(input) {
     return input.length <= 2048 && DID_REGEX.test(input);
 }
-class InvalidDidError extends Error {
+export class InvalidDidError extends Error {
 }
-exports.InvalidDidError = InvalidDidError;
 //# sourceMappingURL=did.js.map

package/dist/did.js.map

@@ -1 +1 @@
-{"version":3,"file":"did.js","sourceRoot":"","sources":["../src/did.ts"],"names":[],"mappings":";AAAA,8BAA8B;AAC9B,iEAAiE;AACjE,+CAA+C;AAC/C,2CAA2C;AAC3C,wEAAwE;AACxE,sFAAsF;AACtF,qFAAqF;AACrF,wHAAwH;AACxH,8GAA8G;AAC9G,6FAA6F;AAC7F,qGAAqG;AACrG,mCAAmC;AACnC,oDAAoD;;;AAIpD,wCAgCC;AAID,kDAYC;AAED,gCAEC;AApDD,SAAgB,cAAc,CAC5B,KAAQ;IAER,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,eAAe,CAAC,4BAA4B,CAAC,CAAA;IACzD,CAAC;IAED,IAAI,KAAK,CAAC,MAAM,GAAG,IAAI,EAAE,CAAC;QACxB,MAAM,IAAI,eAAe,CAAC,kCAAkC,CAAC,CAAA;IAC/D,CAAC;IAED,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QAC/C,MAAM,IAAI,eAAe,CAAC,iCAAiC,CAAC,CAAA;IAC9D,CAAC;IAED,wCAAwC;IACxC,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACvC,MAAM,IAAI,eAAe,CACvB,0FAA0F,CAC3F,CAAA;IACH,CAAC;IAED,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IAC9C,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;QACf,MAAM,IAAI,eAAe,CACvB,0DAA0D,CAC3D,CAAA;IACH,CAAC;IAED,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,eAAe,CAAC,uCAAuC,CAAC,CAAA;IACpE,CAAC;AACH,CAAC;AAED,MAAM,SAAS,GAAG,8CAA8C,CAAA;AAEhE,SAAgB,mBAAmB,CACjC,KAAQ;IAER,sEAAsE;IACtE,mDAAmD;IACnD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,eAAe,CAAC,+BAA+B,CAAC,CAAA;IAC5D,CAAC;IAED,IAAI,KAAK,CAAC,MAAM,GAAG,IAAI,EAAE,CAAC;QACxB,MAAM,IAAI,eAAe,CAAC,kCAAkC,CAAC,CAAA;IAC/D,CAAC;AACH,CAAC;AAED,SAAgB,UAAU,CAAmB,KAAQ;IACnD,OAAO,KAAK,CAAC,MAAM,IAAI,IAAI,IAAI,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;AACtD,CAAC;AAED,MAAa,eAAgB,SAAQ,KAAK;CAAG;AAA7C,0CAA6C","sourcesContent":["// Human-readable constraints:\n//   - valid W3C DID (https://www.w3.org/TR/did-core/#did-syntax)\n//      - entire URI is ASCII: [a-zA-Z0-9._:%-]\n//      - always starts \"did:\" (lower-case)\n//      - method name is one or more lower-case letters, followed by \":\"\n//      - remaining identifier can have any of the above chars, but can not end in \":\"\n//      - it seems that a bunch of \":\" can be included, and don't need spaces between\n//      - \"%\" is used only for \"percent encoding\" and must be followed by two hex characters (and thus can't end in \"%\")\n//      - query (\"?\") and fragment (\"#\") stuff is defined for \"DID URIs\", but not as part of identifier itself\n//      - \"The current specification does not take a position on the maximum length of a DID\"\n//   - in current atproto, only allowing did:plc and did:web. But not *forcing* this at lexicon layer\n//   - hard length limit of 8KBytes\n//   - not going to validate \"percent encoding\" here\n\nexport type DidString<M extends string = string> = `did:${M}:${string}`\n\nexport function ensureValidDid<I extends string>(\n  input: I,\n): asserts input is I & DidString {\n  if (!input.startsWith('did:')) {\n    throw new InvalidDidError('DID requires \"did:\" prefix')\n  }\n\n  if (input.length > 2048) {\n    throw new InvalidDidError('DID is too long (2048 chars max)')\n  }\n\n  if (input.endsWith(':') || input.endsWith('%')) {\n    throw new InvalidDidError('DID can not end with \":\" or \"%\"')\n  }\n\n  // check that all chars are boring ASCII\n  if (!/^[a-zA-Z0-9._:%-]*$/.test(input)) {\n    throw new InvalidDidError(\n      'Disallowed characters in DID (ASCII letters, digits, and a couple other characters only)',\n    )\n  }\n\n  const { length, 1: method } = input.split(':')\n  if (length < 3) {\n    throw new InvalidDidError(\n      'DID requires prefix, method, and method-specific content',\n    )\n  }\n\n  if (!/^[a-z]+$/.test(method)) {\n    throw new InvalidDidError('DID method must be lower-case letters')\n  }\n}\n\nconst DID_REGEX = /^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$/\n\nexport function ensureValidDidRegex<I extends string>(\n  input: I,\n): asserts input is I & DidString {\n  // simple regex to enforce most constraints via just regex and length.\n  // hand wrote this regex based on above constraints\n  if (!DID_REGEX.test(input)) {\n    throw new InvalidDidError(\"DID didn't validate via regex\")\n  }\n\n  if (input.length > 2048) {\n    throw new InvalidDidError('DID is too long (2048 chars max)')\n  }\n}\n\nexport function isValidDid<I extends string>(input: I): input is I & DidString {\n  return input.length <= 2048 && DID_REGEX.test(input)\n}\n\nexport class InvalidDidError extends Error {}\n"]}
+{"version":3,"file":"did.js","sourceRoot":"","sources":["../src/did.ts"],"names":[],"mappings":"AAAA,8BAA8B;AAC9B,iEAAiE;AACjE,+CAA+C;AAC/C,2CAA2C;AAC3C,wEAAwE;AACxE,sFAAsF;AACtF,qFAAqF;AACrF,wHAAwH;AACxH,8GAA8G;AAC9G,6FAA6F;AAC7F,qGAAqG;AACrG,mCAAmC;AACnC,oDAAoD;AAIpD,MAAM,UAAU,cAAc,CAC5B,KAAQ;IAER,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,eAAe,CAAC,4BAA4B,CAAC,CAAA;IACzD,CAAC;IAED,IAAI,KAAK,CAAC,MAAM,GAAG,IAAI,EAAE,CAAC;QACxB,MAAM,IAAI,eAAe,CAAC,kCAAkC,CAAC,CAAA;IAC/D,CAAC;IAED,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QAC/C,MAAM,IAAI,eAAe,CAAC,iCAAiC,CAAC,CAAA;IAC9D,CAAC;IAED,wCAAwC;IACxC,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACvC,MAAM,IAAI,eAAe,CACvB,0FAA0F,CAC3F,CAAA;IACH,CAAC;IAED,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IAC9C,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;QACf,MAAM,IAAI,eAAe,CACvB,0DAA0D,CAC3D,CAAA;IACH,CAAC;IAED,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,eAAe,CAAC,uCAAuC,CAAC,CAAA;IACpE,CAAC;AACH,CAAC;AAED,MAAM,SAAS,GAAG,8CAA8C,CAAA;AAEhE,MAAM,UAAU,mBAAmB,CACjC,KAAQ;IAER,sEAAsE;IACtE,mDAAmD;IACnD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,eAAe,CAAC,+BAA+B,CAAC,CAAA;IAC5D,CAAC;IAED,IAAI,KAAK,CAAC,MAAM,GAAG,IAAI,EAAE,CAAC;QACxB,MAAM,IAAI,eAAe,CAAC,kCAAkC,CAAC,CAAA;IAC/D,CAAC;AACH,CAAC;AAED,MAAM,UAAU,UAAU,CAAmB,KAAQ;IACnD,OAAO,KAAK,CAAC,MAAM,IAAI,IAAI,IAAI,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;AACtD,CAAC;AAED,MAAM,OAAO,eAAgB,SAAQ,KAAK;CAAG","sourcesContent":["// Human-readable constraints:\n//   - valid W3C DID (https://www.w3.org/TR/did-core/#did-syntax)\n//      - entire URI is ASCII: [a-zA-Z0-9._:%-]\n//      - always starts \"did:\" (lower-case)\n//      - method name is one or more lower-case letters, followed by \":\"\n//      - remaining identifier can have any of the above chars, but can not end in \":\"\n//      - it seems that a bunch of \":\" can be included, and don't need spaces between\n//      - \"%\" is used only for \"percent encoding\" and must be followed by two hex characters (and thus can't end in \"%\")\n//      - query (\"?\") and fragment (\"#\") stuff is defined for \"DID URIs\", but not as part of identifier itself\n//      - \"The current specification does not take a position on the maximum length of a DID\"\n//   - in current atproto, only allowing did:plc and did:web. But not *forcing* this at lexicon layer\n//   - hard length limit of 8KBytes\n//   - not going to validate \"percent encoding\" here\n\nexport type DidString<M extends string = string> = `did:${M}:${string}`\n\nexport function ensureValidDid<I extends string>(\n  input: I,\n): asserts input is I & DidString {\n  if (!input.startsWith('did:')) {\n    throw new InvalidDidError('DID requires \"did:\" prefix')\n  }\n\n  if (input.length > 2048) {\n    throw new InvalidDidError('DID is too long (2048 chars max)')\n  }\n\n  if (input.endsWith(':') || input.endsWith('%')) {\n    throw new InvalidDidError('DID can not end with \":\" or \"%\"')\n  }\n\n  // check that all chars are boring ASCII\n  if (!/^[a-zA-Z0-9._:%-]*$/.test(input)) {\n    throw new InvalidDidError(\n      'Disallowed characters in DID (ASCII letters, digits, and a couple other characters only)',\n    )\n  }\n\n  const { length, 1: method } = input.split(':')\n  if (length < 3) {\n    throw new InvalidDidError(\n      'DID requires prefix, method, and method-specific content',\n    )\n  }\n\n  if (!/^[a-z]+$/.test(method)) {\n    throw new InvalidDidError('DID method must be lower-case letters')\n  }\n}\n\nconst DID_REGEX = /^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$/\n\nexport function ensureValidDidRegex<I extends string>(\n  input: I,\n): asserts input is I & DidString {\n  // simple regex to enforce most constraints via just regex and length.\n  // hand wrote this regex based on above constraints\n  if (!DID_REGEX.test(input)) {\n    throw new InvalidDidError(\"DID didn't validate via regex\")\n  }\n\n  if (input.length > 2048) {\n    throw new InvalidDidError('DID is too long (2048 chars max)')\n  }\n}\n\nexport function isValidDid<I extends string>(input: I): input is I & DidString {\n  return input.length <= 2048 && DID_REGEX.test(input)\n}\n\nexport class InvalidDidError extends Error {}\n"]}

package/dist/handle.js

@@ -1,18 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DisallowedDomainError = exports.UnsupportedDomainError = exports.ReservedHandleError = exports.InvalidHandleError = exports.DISALLOWED_TLDS = exports.INVALID_HANDLE = void 0;
-exports.ensureValidHandle = ensureValidHandle;
-exports.ensureValidHandleRegex = ensureValidHandleRegex;
-exports.normalizeHandle = normalizeHandle;
-exports.normalizeAndEnsureValidHandle = normalizeAndEnsureValidHandle;
-exports.isValidHandle = isValidHandle;
-exports.isValidTld = isValidTld;
-exports.INVALID_HANDLE = 'handle.invalid';
+export const INVALID_HANDLE = 'handle.invalid';
 // Currently these are registration-time restrictions, not protocol-level
 // restrictions. We have a couple accounts in the wild that we need to clean up
 // before hard-disallow.
 // See also: https://en.wikipedia.org/wiki/Top-level_domain#Reserved_domains
-exports.DISALLOWED_TLDS = [
+export const DISALLOWED_TLDS = [
     '.local',
     '.arpa',
     '.invalid',
@@ -44,7 +35,7 @@ exports.DISALLOWED_TLDS = [
 //  - does not validate whether domain or TLD exists, or is a reserved or
 //    special TLD (eg, .onion or .local)
 //  - does not validate punycode
-function ensureValidHandle(input) {
+export function ensureValidHandle(input) {
     // check that all chars are boring ASCII
     if (!/^[a-zA-Z0-9.-]*$/.test(input)) {
         throw new InvalidHandleError('Disallowed characters in handle (ASCII letters, digits, dashes, periods only)');
@@ -74,7 +65,7 @@ function ensureValidHandle(input) {
 }
 // simple regex translation of above constraints
 const HANDLE_REGEX = /^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/;
-function ensureValidHandleRegex(input) {
+export function ensureValidHandleRegex(input) {
     if (input.length > 253) {
         throw new InvalidHandleError('Handle is too long (253 chars max)');
     }
@@ -82,38 +73,34 @@ function ensureValidHandleRegex(input) {
         throw new InvalidHandleError("Handle didn't validate via regex");
     }
 }
-function normalizeHandle(handle) {
+export function normalizeHandle(handle) {
     return handle.toLowerCase();
 }
-function normalizeAndEnsureValidHandle(handle) {
+export function normalizeAndEnsureValidHandle(handle) {
     const normalized = normalizeHandle(handle);
     ensureValidHandle(normalized);
     return normalized;
 }
-function isValidHandle(input) {
+export function isValidHandle(input) {
     return input.length <= 253 && HANDLE_REGEX.test(input);
 }
-function isValidTld(handle) {
-    for (const tld of exports.DISALLOWED_TLDS) {
+export function isValidTld(handle) {
+    for (const tld of DISALLOWED_TLDS) {
         if (handle.endsWith(tld)) {
             return false;
         }
     }
     return true;
 }
-class InvalidHandleError extends Error {
+export class InvalidHandleError extends Error {
 }
-exports.InvalidHandleError = InvalidHandleError;
 /** @deprecated Never used */
-class ReservedHandleError extends Error {
+export class ReservedHandleError extends Error {
 }
-exports.ReservedHandleError = ReservedHandleError;
 /** @deprecated Never used */
-class UnsupportedDomainError extends Error {
+export class UnsupportedDomainError extends Error {
 }
-exports.UnsupportedDomainError = UnsupportedDomainError;
 /** @deprecated Never used */
-class DisallowedDomainError extends Error {
+export class DisallowedDomainError extends Error {
 }
-exports.DisallowedDomainError = DisallowedDomainError;
 //# sourceMappingURL=handle.js.map

package/dist/handle.js.map

@@ -1 +1 @@
-{"version":3,"file":"handle.js","sourceRoot":"","sources":["../src/handle.ts"],"names":[],"mappings":"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","sourcesContent":["export const INVALID_HANDLE = 'handle.invalid'\n\nexport type HandleString = `${string}.${string}`\n\n// Currently these are registration-time restrictions, not protocol-level\n// restrictions. We have a couple accounts in the wild that we need to clean up\n// before hard-disallow.\n// See also: https://en.wikipedia.org/wiki/Top-level_domain#Reserved_domains\nexport const DISALLOWED_TLDS = [\n  '.local',\n  '.arpa',\n  '.invalid',\n  '.localhost',\n  '.internal',\n  '.example',\n  '.alt',\n  // policy could concievably change on \".onion\" some day\n  '.onion',\n  // NOTE: .test is allowed in testing and devopment. In practical terms\n  // \"should\" \"never\" actually resolve and get registered in production\n]\n\n// Handle constraints, in English:\n//  - must be a possible domain name\n//    - RFC-1035 is commonly referenced, but has been updated. eg, RFC-3696,\n//      section 2. and RFC-3986, section 3. can now have leading numbers (eg,\n//      4chan.org)\n//    - \"labels\" (sub-names) are made of ASCII letters, digits, hyphens\n//    - can not start or end with a hyphen\n//    - TLD (last component) should not start with a digit\n//    - can't end with a hyphen (can end with digit)\n//    - each segment must be between 1 and 63 characters (not including any periods)\n//    - overall length can't be more than 253 characters\n//    - separated by (ASCII) periods; does not start or end with period\n//    - case insensitive\n//    - domains (handles) are equal if they are the same lower-case\n//    - punycode allowed for internationalization\n//  - no whitespace, null bytes, joining chars, etc\n//  - does not validate whether domain or TLD exists, or is a reserved or\n//    special TLD (eg, .onion or .local)\n//  - does not validate punycode\nexport function ensureValidHandle<I extends string>(\n  input: I,\n): asserts input is I & HandleString {\n  // check that all chars are boring ASCII\n  if (!/^[a-zA-Z0-9.-]*$/.test(input)) {\n    throw new InvalidHandleError(\n      'Disallowed characters in handle (ASCII letters, digits, dashes, periods only)',\n    )\n  }\n\n  if (input.length > 253) {\n    throw new InvalidHandleError('Handle is too long (253 chars max)')\n  }\n  const labels = input.split('.')\n  if (labels.length < 2) {\n    throw new InvalidHandleError('Handle domain needs at least two parts')\n  }\n  for (let i = 0; i < labels.length; i++) {\n    const l = labels[i]\n    if (l.length < 1) {\n      throw new InvalidHandleError('Handle parts can not be empty')\n    }\n    if (l.length > 63) {\n      throw new InvalidHandleError('Handle part too long (max 63 chars)')\n    }\n    if (l.endsWith('-') || l.startsWith('-')) {\n      throw new InvalidHandleError(\n        'Handle parts can not start or end with hyphens',\n      )\n    }\n    if (i + 1 === labels.length && !/^[a-zA-Z]/.test(l)) {\n      throw new InvalidHandleError(\n        'Handle final component (TLD) must start with ASCII letter',\n      )\n    }\n  }\n}\n\n// simple regex translation of above constraints\nconst HANDLE_REGEX =\n  /^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/\n\nexport function ensureValidHandleRegex<I extends string>(\n  input: I,\n): asserts input is I & HandleString {\n  if (input.length > 253) {\n    throw new InvalidHandleError('Handle is too long (253 chars max)')\n  }\n  if (!HANDLE_REGEX.test(input)) {\n    throw new InvalidHandleError(\"Handle didn't validate via regex\")\n  }\n}\n\nexport function normalizeHandle(handle: HandleString): HandleString\nexport function normalizeHandle(handle: string): string\nexport function normalizeHandle(handle: string): string {\n  return handle.toLowerCase()\n}\n\nexport function normalizeAndEnsureValidHandle(handle: string): HandleString {\n  const normalized = normalizeHandle(handle)\n  ensureValidHandle(normalized)\n  return normalized\n}\n\nexport function isValidHandle<I extends string>(\n  input: I,\n): input is I & HandleString {\n  return input.length <= 253 && HANDLE_REGEX.test(input)\n}\n\nexport function isValidTld(handle: string): boolean {\n  for (const tld of DISALLOWED_TLDS) {\n    if (handle.endsWith(tld)) {\n      return false\n    }\n  }\n  return true\n}\n\nexport class InvalidHandleError extends Error {}\n/** @deprecated Never used */\nexport class ReservedHandleError extends Error {}\n/** @deprecated Never used */\nexport class UnsupportedDomainError extends Error {}\n/** @deprecated Never used */\nexport class DisallowedDomainError extends Error {}\n"]}
+{"version":3,"file":"handle.js","sourceRoot":"","sources":["../src/handle.ts"],"names":[],"mappings":"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","sourcesContent":["export const INVALID_HANDLE = 'handle.invalid'\n\nexport type HandleString = `${string}.${string}`\n\n// Currently these are registration-time restrictions, not protocol-level\n// restrictions. We have a couple accounts in the wild that we need to clean up\n// before hard-disallow.\n// See also: https://en.wikipedia.org/wiki/Top-level_domain#Reserved_domains\nexport const DISALLOWED_TLDS = [\n  '.local',\n  '.arpa',\n  '.invalid',\n  '.localhost',\n  '.internal',\n  '.example',\n  '.alt',\n  // policy could concievably change on \".onion\" some day\n  '.onion',\n  // NOTE: .test is allowed in testing and devopment. In practical terms\n  // \"should\" \"never\" actually resolve and get registered in production\n]\n\n// Handle constraints, in English:\n//  - must be a possible domain name\n//    - RFC-1035 is commonly referenced, but has been updated. eg, RFC-3696,\n//      section 2. and RFC-3986, section 3. can now have leading numbers (eg,\n//      4chan.org)\n//    - \"labels\" (sub-names) are made of ASCII letters, digits, hyphens\n//    - can not start or end with a hyphen\n//    - TLD (last component) should not start with a digit\n//    - can't end with a hyphen (can end with digit)\n//    - each segment must be between 1 and 63 characters (not including any periods)\n//    - overall length can't be more than 253 characters\n//    - separated by (ASCII) periods; does not start or end with period\n//    - case insensitive\n//    - domains (handles) are equal if they are the same lower-case\n//    - punycode allowed for internationalization\n//  - no whitespace, null bytes, joining chars, etc\n//  - does not validate whether domain or TLD exists, or is a reserved or\n//    special TLD (eg, .onion or .local)\n//  - does not validate punycode\nexport function ensureValidHandle<I extends string>(\n  input: I,\n): asserts input is I & HandleString {\n  // check that all chars are boring ASCII\n  if (!/^[a-zA-Z0-9.-]*$/.test(input)) {\n    throw new InvalidHandleError(\n      'Disallowed characters in handle (ASCII letters, digits, dashes, periods only)',\n    )\n  }\n\n  if (input.length > 253) {\n    throw new InvalidHandleError('Handle is too long (253 chars max)')\n  }\n  const labels = input.split('.')\n  if (labels.length < 2) {\n    throw new InvalidHandleError('Handle domain needs at least two parts')\n  }\n  for (let i = 0; i < labels.length; i++) {\n    const l = labels[i]\n    if (l.length < 1) {\n      throw new InvalidHandleError('Handle parts can not be empty')\n    }\n    if (l.length > 63) {\n      throw new InvalidHandleError('Handle part too long (max 63 chars)')\n    }\n    if (l.endsWith('-') || l.startsWith('-')) {\n      throw new InvalidHandleError(\n        'Handle parts can not start or end with hyphens',\n      )\n    }\n    if (i + 1 === labels.length && !/^[a-zA-Z]/.test(l)) {\n      throw new InvalidHandleError(\n        'Handle final component (TLD) must start with ASCII letter',\n      )\n    }\n  }\n}\n\n// simple regex translation of above constraints\nconst HANDLE_REGEX =\n  /^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/\n\nexport function ensureValidHandleRegex<I extends string>(\n  input: I,\n): asserts input is I & HandleString {\n  if (input.length > 253) {\n    throw new InvalidHandleError('Handle is too long (253 chars max)')\n  }\n  if (!HANDLE_REGEX.test(input)) {\n    throw new InvalidHandleError(\"Handle didn't validate via regex\")\n  }\n}\n\nexport function normalizeHandle(handle: HandleString): HandleString\nexport function normalizeHandle(handle: string): string\nexport function normalizeHandle(handle: string): string {\n  return handle.toLowerCase()\n}\n\nexport function normalizeAndEnsureValidHandle(handle: string): HandleString {\n  const normalized = normalizeHandle(handle)\n  ensureValidHandle(normalized)\n  return normalized\n}\n\nexport function isValidHandle<I extends string>(\n  input: I,\n): input is I & HandleString {\n  return input.length <= 253 && HANDLE_REGEX.test(input)\n}\n\nexport function isValidTld(handle: string): boolean {\n  for (const tld of DISALLOWED_TLDS) {\n    if (handle.endsWith(tld)) {\n      return false\n    }\n  }\n  return true\n}\n\nexport class InvalidHandleError extends Error {}\n/** @deprecated Never used */\nexport class ReservedHandleError extends Error {}\n/** @deprecated Never used */\nexport class UnsupportedDomainError extends Error {}\n/** @deprecated Never used */\nexport class DisallowedDomainError extends Error {}\n"]}

package/dist/index.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./at-identifier.js"), exports);
-tslib_1.__exportStar(require("./aturi.js"), exports);
-tslib_1.__exportStar(require("./datetime.js"), exports);
-tslib_1.__exportStar(require("./did.js"), exports);
-tslib_1.__exportStar(require("./handle.js"), exports);
-tslib_1.__exportStar(require("./nsid.js"), exports);
-tslib_1.__exportStar(require("./language.js"), exports);
-tslib_1.__exportStar(require("./recordkey.js"), exports);
-tslib_1.__exportStar(require("./tid.js"), exports);
-tslib_1.__exportStar(require("./uri.js"), exports);
+export * from './at-identifier.js';
+export * from './aturi.js';
+export * from './datetime.js';
+export * from './did.js';
+export * from './handle.js';
+export * from './nsid.js';
+export * from './language.js';
+export * from './recordkey.js';
+export * from './tid.js';
+export * from './uri.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,6DAAkC;AAClC,qDAA0B;AAC1B,wDAA6B;AAC7B,mDAAwB;AACxB,sDAA2B;AAC3B,oDAAyB;AACzB,wDAA6B;AAC7B,yDAA8B;AAC9B,mDAAwB;AACxB,mDAAwB","sourcesContent":["export * from './at-identifier.js'\nexport * from './aturi.js'\nexport * from './datetime.js'\nexport * from './did.js'\nexport * from './handle.js'\nexport * from './nsid.js'\nexport * from './language.js'\nexport * from './recordkey.js'\nexport * from './tid.js'\nexport * from './uri.js'\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA;AAC1B,cAAc,eAAe,CAAA;AAC7B,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,WAAW,CAAA;AACzB,cAAc,eAAe,CAAA;AAC7B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA","sourcesContent":["export * from './at-identifier.js'\nexport * from './aturi.js'\nexport * from './datetime.js'\nexport * from './did.js'\nexport * from './handle.js'\nexport * from './nsid.js'\nexport * from './language.js'\nexport * from './recordkey.js'\nexport * from './tid.js'\nexport * from './uri.js'\n"]}

package/dist/language.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseLanguageString = parseLanguageString;
-exports.isValidLanguage = isValidLanguage;
 const BCP47_REGEXP = /^((?<grandfathered>(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang))|((?<language>([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?)|[A-Za-z]{4}|[A-Za-z]{5,8})(-(?<script>[A-Za-z]{4}))?(-(?<region>[A-Za-z]{2}|[0-9]{3}))?(-(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*(-(?<extension>[0-9A-WY-Za-wy-z](-[A-Za-z0-9]{2,8})+))*(-(?<privateUseA>x(-[A-Za-z0-9]{1,8})+))?)|(?<privateUseB>x(-[A-Za-z0-9]{1,8})+))$/;
-function parseLanguageString(input) {
+export function parseLanguageString(input) {
     const parsed = input.match(BCP47_REGEXP);
     if (!parsed?.groups)
         return null;
@@ -24,7 +20,7 @@ function parseLanguageString(input) {
  *
  * @see {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1}
  */
-function isValidLanguage(input) {
+export function isValidLanguage(input) {
     return BCP47_REGEXP.test(input);
 }
 //# sourceMappingURL=language.js.map

package/dist/language.js.map

@@ -1 +1 @@
-{"version":3,"file":"language.js","sourceRoot":"","sources":["../src/language.ts"],"names":[],"mappings":";;AAcA,kDAeC;AAOD,0CAEC;AAtCD,MAAM,YAAY,GAChB,mlBAAmlB,CAAA;AAarlB,SAAgB,mBAAmB,CAAC,KAAa;IAC/C,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC,CAAA;IACxC,IAAI,CAAC,MAAM,EAAE,MAAM;QAAE,OAAO,IAAI,CAAA;IAEhC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAAA;IACzB,OAAO;QACL,aAAa,EAAE,MAAM,CAAC,aAAa;QACnC,QAAQ,EAAE,MAAM,CAAC,QAAQ;QACzB,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,UAAU,EAAE,MAAM,CAAC,WAAW,IAAI,MAAM,CAAC,WAAW;KACrD,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAgB,eAAe,CAAC,KAAa;IAC3C,OAAO,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;AACjC,CAAC","sourcesContent":["const BCP47_REGEXP =\n  /^((?<grandfathered>(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang))|((?<language>([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?)|[A-Za-z]{4}|[A-Za-z]{5,8})(-(?<script>[A-Za-z]{4}))?(-(?<region>[A-Za-z]{2}|[0-9]{3}))?(-(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*(-(?<extension>[0-9A-WY-Za-wy-z](-[A-Za-z0-9]{2,8})+))*(-(?<privateUseA>x(-[A-Za-z0-9]{1,8})+))?)|(?<privateUseB>x(-[A-Za-z0-9]{1,8})+))$/\n\nexport type LanguageTag = {\n  grandfathered?: string\n  language?: string\n  extlang?: string\n  script?: string\n  region?: string\n  variant?: string\n  extension?: string\n  privateUse?: string\n}\n\nexport function parseLanguageString(input: string): LanguageTag | null {\n  const parsed = input.match(BCP47_REGEXP)\n  if (!parsed?.groups) return null\n\n  const { groups } = parsed\n  return {\n    grandfathered: groups.grandfathered,\n    language: groups.language,\n    extlang: groups.extlang,\n    script: groups.script,\n    region: groups.region,\n    variant: groups.variant,\n    extension: groups.extension,\n    privateUse: groups.privateUseA || groups.privateUseB,\n  }\n}\n\n/**\n * Validates well-formed BCP 47 syntax\n *\n * @see {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1}\n */\nexport function isValidLanguage(input: string): boolean {\n  return BCP47_REGEXP.test(input)\n}\n"]}
+{"version":3,"file":"language.js","sourceRoot":"","sources":["../src/language.ts"],"names":[],"mappings":"AAAA,MAAM,YAAY,GAChB,mlBAAmlB,CAAA;AAarlB,MAAM,UAAU,mBAAmB,CAAC,KAAa;IAC/C,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC,CAAA;IACxC,IAAI,CAAC,MAAM,EAAE,MAAM;QAAE,OAAO,IAAI,CAAA;IAEhC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAAA;IACzB,OAAO;QACL,aAAa,EAAE,MAAM,CAAC,aAAa;QACnC,QAAQ,EAAE,MAAM,CAAC,QAAQ;QACzB,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,UAAU,EAAE,MAAM,CAAC,WAAW,IAAI,MAAM,CAAC,WAAW;KACrD,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,KAAa;IAC3C,OAAO,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;AACjC,CAAC","sourcesContent":["const BCP47_REGEXP =\n  /^((?<grandfathered>(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang))|((?<language>([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?)|[A-Za-z]{4}|[A-Za-z]{5,8})(-(?<script>[A-Za-z]{4}))?(-(?<region>[A-Za-z]{2}|[0-9]{3}))?(-(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*(-(?<extension>[0-9A-WY-Za-wy-z](-[A-Za-z0-9]{2,8})+))*(-(?<privateUseA>x(-[A-Za-z0-9]{1,8})+))?)|(?<privateUseB>x(-[A-Za-z0-9]{1,8})+))$/\n\nexport type LanguageTag = {\n  grandfathered?: string\n  language?: string\n  extlang?: string\n  script?: string\n  region?: string\n  variant?: string\n  extension?: string\n  privateUse?: string\n}\n\nexport function parseLanguageString(input: string): LanguageTag | null {\n  const parsed = input.match(BCP47_REGEXP)\n  if (!parsed?.groups) return null\n\n  const { groups } = parsed\n  return {\n    grandfathered: groups.grandfathered,\n    language: groups.language,\n    extlang: groups.extlang,\n    script: groups.script,\n    region: groups.region,\n    variant: groups.variant,\n    extension: groups.extension,\n    privateUse: groups.privateUseA || groups.privateUseB,\n  }\n}\n\n/**\n * Validates well-formed BCP 47 syntax\n *\n * @see {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1}\n */\nexport function isValidLanguage(input: string): boolean {\n  return BCP47_REGEXP.test(input)\n}\n"]}

package/dist/lib/result.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.success = success;
-exports.failure = failure;
-function success(value) {
+export function success(value) {
     return { success: true, value };
 }
-function failure(message) {
+export function failure(message) {
     return { success: false, message };
 }
 //# sourceMappingURL=result.js.map

package/dist/lib/result.js.map

@@ -1 +1 @@
-{"version":3,"file":"result.js","sourceRoot":"","sources":["../../src/lib/result.ts"],"names":[],"mappings":";;AAGA,0BAEC;AAGD,0BAEC;AAPD,SAAgB,OAAO,CAAI,KAAQ;IACjC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAA;AACjC,CAAC;AAGD,SAAgB,OAAO,CAAC,OAAe;IACrC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAA;AACpC,CAAC","sourcesContent":["export type Result<T> = Success<T> | Failure\n\nexport type Success<T> = { success: true; value: T }\nexport function success<T>(value: T): Success<T> {\n  return { success: true, value }\n}\n\nexport type Failure = { success: false; message: string }\nexport function failure(message: string): Failure {\n  return { success: false, message }\n}\n"]}
+{"version":3,"file":"result.js","sourceRoot":"","sources":["../../src/lib/result.ts"],"names":[],"mappings":"AAGA,MAAM,UAAU,OAAO,CAAI,KAAQ;IACjC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,CAAA;AACjC,CAAC;AAGD,MAAM,UAAU,OAAO,CAAC,OAAe;IACrC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAA;AACpC,CAAC","sourcesContent":["export type Result<T> = Success<T> | Failure\n\nexport type Success<T> = { success: true; value: T }\nexport function success<T>(value: T): Success<T> {\n  return { success: true, value }\n}\n\nexport type Failure = { success: false; message: string }\nexport function failure(message: string): Failure {\n  return { success: false, message }\n}\n"]}

package/dist/nsid.js

@@ -1,15 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidNsidError = exports.NSID = void 0;
-exports.ensureValidNsid = ensureValidNsid;
-exports.parseNsid = parseNsid;
-exports.isValidNsid = isValidNsid;
-exports.validateNsid = validateNsid;
-exports.ensureValidNsidRegex = ensureValidNsidRegex;
-exports.validateNsidRegex = validateNsidRegex;
-const result_js_1 = require("./lib/result.js");
-class NSID {
-    segments;
+import { failure, success } from './lib/result.js';
+export class NSID {
     static parse(input) {
         return new NSID(input);
     }
@@ -46,19 +36,18 @@ class NSID {
         return this.segments.join('.');
     }
 }
-exports.NSID = NSID;
-function ensureValidNsid(input) {
+export function ensureValidNsid(input) {
     const result = validateNsid(input);
     if (!result.success)
         throw new InvalidNsidError(result.message);
 }
-function parseNsid(nsid) {
+export function parseNsid(nsid) {
     const result = validateNsid(nsid);
     if (!result.success)
         throw new InvalidNsidError(result.message);
     return result.value;
 }
-function isValidNsid(input) {
+export function isValidNsid(input) {
     // Since the regex version is more performant for valid NSIDs, we use it when
     // we don't care about error details.
     return validateNsidRegex(input).success;
@@ -66,35 +55,35 @@ function isValidNsid(input) {
 // Human readable constraints on NSID:
 // - a valid domain in reversed notation
 // - followed by an additional period-separated name, which is camel-case letters
-function validateNsid(input) {
+export function validateNsid(input) {
     if (input.length > 253 + 1 + 63) {
-        return (0, result_js_1.failure)('NSID is too long (317 chars max)');
+        return failure('NSID is too long (317 chars max)');
     }
     if (hasDisallowedCharacters(input)) {
-        return (0, result_js_1.failure)('Disallowed characters in NSID (ASCII letters, digits, dashes, periods only)');
+        return failure('Disallowed characters in NSID (ASCII letters, digits, dashes, periods only)');
     }
     const segments = input.split('.');
     if (segments.length < 3) {
-        return (0, result_js_1.failure)('NSID needs at least three parts');
+        return failure('NSID needs at least three parts');
     }
     for (const l of segments) {
         if (l.length < 1) {
-            return (0, result_js_1.failure)('NSID parts can not be empty');
+            return failure('NSID parts can not be empty');
         }
         if (l.length > 63) {
-            return (0, result_js_1.failure)('NSID part too long (max 63 chars)');
+            return failure('NSID part too long (max 63 chars)');
         }
         if (startsWithHyphen(l) || endsWithHyphen(l)) {
-            return (0, result_js_1.failure)('NSID parts can not start or end with hyphen');
+            return failure('NSID parts can not start or end with hyphen');
         }
     }
     if (startsWithNumber(segments[0])) {
-        return (0, result_js_1.failure)('NSID first part may not start with a digit');
+        return failure('NSID first part may not start with a digit');
     }
     if (!isValidIdentifier(segments[segments.length - 1])) {
-        return (0, result_js_1.failure)('NSID name part must be only letters and digits (and no leading digit)');
+        return failure('NSID name part must be only letters and digits (and no leading digit)');
     }
-    return (0, result_js_1.success)(segments);
+    return success(segments);
 }
 function hasDisallowedCharacters(v) {
     return !/^[a-zA-Z0-9.-]*$/.test(v);
@@ -121,7 +110,7 @@ function isValidIdentifier(v) {
  * {@link parseNsid}/{@link NSID.parse} if you need the parsed segments, or
  * {@link isValidNsid} if you just want a boolean.
  */
-function ensureValidNsidRegex(nsid) {
+export function ensureValidNsidRegex(nsid) {
     const result = validateNsidRegex(nsid);
     if (!result.success)
         throw new InvalidNsidError(result.message);
@@ -130,19 +119,18 @@ function ensureValidNsidRegex(nsid) {
  * Regexp based validation that behaves identically to the previous code but
  * provides less detailed error messages (while being 20% to 50% faster).
  */
-function validateNsidRegex(value) {
+export function validateNsidRegex(value) {
     if (value.length > 253 + 1 + 63) {
-        return (0, result_js_1.failure)('NSID is too long (317 chars max)');
+        return failure('NSID is too long (317 chars max)');
     }
     if (
     // Fast check for small values
     value.length < 5 ||
         !/^[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?:\.[a-zA-Z](?:[a-zA-Z0-9]{0,62})?)$/.test(value)) {
-        return (0, result_js_1.failure)("NSID didn't validate via regex");
+        return failure("NSID didn't validate via regex");
     }
-    return (0, result_js_1.success)(value);
+    return success(value);
 }
-class InvalidNsidError extends Error {
+export class InvalidNsidError extends Error {
 }
-exports.InvalidNsidError = InvalidNsidError;
 //# sourceMappingURL=nsid.js.map