@credo-ts/askar-to-drizzle-storage-migration 0.6.0-pr-2429-20251001122134 → 0.6.0-pr-2444-20251009192721

package/build/node_modules/.pnpm/luxon@3.5.0/node_modules/luxon/src/impl/regexParser.mjs

@@ -0,0 +1,199 @@
+import IANAZone from "../zones/IANAZone.mjs";
+import FixedOffsetZone from "../zones/fixedOffsetZone.mjs";
+import { isUndefined, parseFloating, parseInteger, parseMillis, signedOffset, untruncateYear } from "./util.mjs";
+import { monthsShort, weekdaysLong, weekdaysShort } from "./english.mjs";
+
+//#region ../../node_modules/.pnpm/luxon@3.5.0/node_modules/luxon/src/impl/regexParser.js
+const ianaRegex = /[A-Za-z_+-]{1,256}(?::?\/[A-Za-z0-9_+-]{1,256}(?:\/[A-Za-z0-9_+-]{1,256})?)?/;
+function combineRegexes(...regexes) {
+	const full = regexes.reduce((f, r) => f + r.source, "");
+	return RegExp(`^${full}$`);
+}
+function combineExtractors(...extractors) {
+	return (m) => extractors.reduce(([mergedVals, mergedZone, cursor], ex) => {
+		const [val, zone, next] = ex(m, cursor);
+		return [
+			{
+				...mergedVals,
+				...val
+			},
+			zone || mergedZone,
+			next
+		];
+	}, [
+		{},
+		null,
+		1
+	]).slice(0, 2);
+}
+function parse(s, ...patterns) {
+	if (s == null) return [null, null];
+	for (const [regex, extractor] of patterns) {
+		const m = regex.exec(s);
+		if (m) return extractor(m);
+	}
+	return [null, null];
+}
+function simpleParse(...keys) {
+	return (match, cursor) => {
+		const ret = {};
+		let i;
+		for (i = 0; i < keys.length; i++) ret[keys[i]] = parseInteger(match[cursor + i]);
+		return [
+			ret,
+			null,
+			cursor + i
+		];
+	};
+}
+const offsetRegex = /(?:(Z)|([+-]\d\d)(?::?(\d\d))?)/;
+const isoExtendedZone = `(?:${offsetRegex.source}?(?:\\[(${ianaRegex.source})\\])?)?`;
+const isoTimeBaseRegex = /(\d\d)(?::?(\d\d)(?::?(\d\d)(?:[.,](\d{1,30}))?)?)?/;
+const isoTimeRegex = RegExp(`${isoTimeBaseRegex.source}${isoExtendedZone}`);
+const isoTimeExtensionRegex = RegExp(`(?:T${isoTimeRegex.source})?`);
+const isoYmdRegex = /([+-]\d{6}|\d{4})(?:-?(\d\d)(?:-?(\d\d))?)?/;
+const isoWeekRegex = /(\d{4})-?W(\d\d)(?:-?(\d))?/;
+const isoOrdinalRegex = /(\d{4})-?(\d{3})/;
+const extractISOWeekData = simpleParse("weekYear", "weekNumber", "weekDay");
+const extractISOOrdinalData = simpleParse("year", "ordinal");
+const sqlYmdRegex = /(\d{4})-(\d\d)-(\d\d)/;
+const sqlTimeRegex = RegExp(`${isoTimeBaseRegex.source} ?(?:${offsetRegex.source}|(${ianaRegex.source}))?`);
+const sqlTimeExtensionRegex = RegExp(`(?: ${sqlTimeRegex.source})?`);
+function int(match, pos, fallback) {
+	const m = match[pos];
+	return isUndefined(m) ? fallback : parseInteger(m);
+}
+function extractISOYmd(match, cursor) {
+	return [
+		{
+			year: int(match, cursor),
+			month: int(match, cursor + 1, 1),
+			day: int(match, cursor + 2, 1)
+		},
+		null,
+		cursor + 3
+	];
+}
+function extractISOTime(match, cursor) {
+	return [
+		{
+			hours: int(match, cursor, 0),
+			minutes: int(match, cursor + 1, 0),
+			seconds: int(match, cursor + 2, 0),
+			milliseconds: parseMillis(match[cursor + 3])
+		},
+		null,
+		cursor + 4
+	];
+}
+function extractISOOffset(match, cursor) {
+	const local = !match[cursor] && !match[cursor + 1], fullOffset = signedOffset(match[cursor + 1], match[cursor + 2]);
+	return [
+		{},
+		local ? null : FixedOffsetZone.instance(fullOffset),
+		cursor + 3
+	];
+}
+function extractIANAZone(match, cursor) {
+	return [
+		{},
+		match[cursor] ? IANAZone.create(match[cursor]) : null,
+		cursor + 1
+	];
+}
+const isoTimeOnly = RegExp(`^T?${isoTimeBaseRegex.source}$`);
+const isoDuration = /^-?P(?:(?:(-?\d{1,20}(?:\.\d{1,20})?)Y)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20}(?:\.\d{1,20})?)W)?(?:(-?\d{1,20}(?:\.\d{1,20})?)D)?(?:T(?:(-?\d{1,20}(?:\.\d{1,20})?)H)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20})(?:[.,](-?\d{1,20}))?S)?)?)$/;
+function extractISODuration(match) {
+	const [s, yearStr, monthStr, weekStr, dayStr, hourStr, minuteStr, secondStr, millisecondsStr] = match;
+	const hasNegativePrefix = s[0] === "-";
+	const negativeSeconds = secondStr && secondStr[0] === "-";
+	const maybeNegate = (num, force = false) => num !== void 0 && (force || num && hasNegativePrefix) ? -num : num;
+	return [{
+		years: maybeNegate(parseFloating(yearStr)),
+		months: maybeNegate(parseFloating(monthStr)),
+		weeks: maybeNegate(parseFloating(weekStr)),
+		days: maybeNegate(parseFloating(dayStr)),
+		hours: maybeNegate(parseFloating(hourStr)),
+		minutes: maybeNegate(parseFloating(minuteStr)),
+		seconds: maybeNegate(parseFloating(secondStr), secondStr === "-0"),
+		milliseconds: maybeNegate(parseMillis(millisecondsStr), negativeSeconds)
+	}];
+}
+const obsOffsets = {
+	GMT: 0,
+	EDT: -240,
+	EST: -300,
+	CDT: -300,
+	CST: -360,
+	MDT: -360,
+	MST: -420,
+	PDT: -420,
+	PST: -480
+};
+function fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
+	const result = {
+		year: yearStr.length === 2 ? untruncateYear(parseInteger(yearStr)) : parseInteger(yearStr),
+		month: monthsShort.indexOf(monthStr) + 1,
+		day: parseInteger(dayStr),
+		hour: parseInteger(hourStr),
+		minute: parseInteger(minuteStr)
+	};
+	if (secondStr) result.second = parseInteger(secondStr);
+	if (weekdayStr) result.weekday = weekdayStr.length > 3 ? weekdaysLong.indexOf(weekdayStr) + 1 : weekdaysShort.indexOf(weekdayStr) + 1;
+	return result;
+}
+const rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|(?:([+-]\d\d)(\d\d)))$/;
+function extractRFC2822(match) {
+	const [, weekdayStr, dayStr, monthStr, yearStr, hourStr, minuteStr, secondStr, obsOffset, milOffset, offHourStr, offMinuteStr] = match, result = fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr);
+	let offset;
+	if (obsOffset) offset = obsOffsets[obsOffset];
+	else if (milOffset) offset = 0;
+	else offset = signedOffset(offHourStr, offMinuteStr);
+	return [result, new FixedOffsetZone(offset)];
+}
+function preprocessRFC2822(s) {
+	return s.replace(/\([^()]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").trim();
+}
+const rfc1123 = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d\d) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d\d):(\d\d):(\d\d) GMT$/, rfc850 = /^(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d\d)-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d\d) (\d\d):(\d\d):(\d\d) GMT$/, ascii = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( \d|\d\d) (\d\d):(\d\d):(\d\d) (\d{4})$/;
+function extractRFC1123Or850(match) {
+	const [, weekdayStr, dayStr, monthStr, yearStr, hourStr, minuteStr, secondStr] = match;
+	return [fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr), FixedOffsetZone.utcInstance];
+}
+function extractASCII(match) {
+	const [, weekdayStr, monthStr, dayStr, hourStr, minuteStr, secondStr, yearStr] = match;
+	return [fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr), FixedOffsetZone.utcInstance];
+}
+const isoYmdWithTimeExtensionRegex = combineRegexes(isoYmdRegex, isoTimeExtensionRegex);
+const isoWeekWithTimeExtensionRegex = combineRegexes(isoWeekRegex, isoTimeExtensionRegex);
+const isoOrdinalWithTimeExtensionRegex = combineRegexes(isoOrdinalRegex, isoTimeExtensionRegex);
+const isoTimeCombinedRegex = combineRegexes(isoTimeRegex);
+const extractISOYmdTimeAndOffset = combineExtractors(extractISOYmd, extractISOTime, extractISOOffset, extractIANAZone);
+const extractISOWeekTimeAndOffset = combineExtractors(extractISOWeekData, extractISOTime, extractISOOffset, extractIANAZone);
+const extractISOOrdinalDateAndTime = combineExtractors(extractISOOrdinalData, extractISOTime, extractISOOffset, extractIANAZone);
+const extractISOTimeAndOffset = combineExtractors(extractISOTime, extractISOOffset, extractIANAZone);
+function parseISODate(s) {
+	return parse(s, [isoYmdWithTimeExtensionRegex, extractISOYmdTimeAndOffset], [isoWeekWithTimeExtensionRegex, extractISOWeekTimeAndOffset], [isoOrdinalWithTimeExtensionRegex, extractISOOrdinalDateAndTime], [isoTimeCombinedRegex, extractISOTimeAndOffset]);
+}
+function parseRFC2822Date(s) {
+	return parse(preprocessRFC2822(s), [rfc2822, extractRFC2822]);
+}
+function parseHTTPDate(s) {
+	return parse(s, [rfc1123, extractRFC1123Or850], [rfc850, extractRFC1123Or850], [ascii, extractASCII]);
+}
+function parseISODuration(s) {
+	return parse(s, [isoDuration, extractISODuration]);
+}
+const extractISOTimeOnly = combineExtractors(extractISOTime);
+function parseISOTimeOnly(s) {
+	return parse(s, [isoTimeOnly, extractISOTimeOnly]);
+}
+const sqlYmdWithTimeExtensionRegex = combineRegexes(sqlYmdRegex, sqlTimeExtensionRegex);
+const sqlTimeCombinedRegex = combineRegexes(sqlTimeRegex);
+const extractISOTimeOffsetAndIANAZone = combineExtractors(extractISOTime, extractISOOffset, extractIANAZone);
+function parseSQL(s) {
+	return parse(s, [sqlYmdWithTimeExtensionRegex, extractISOYmdTimeAndOffset], [sqlTimeCombinedRegex, extractISOTimeOffsetAndIANAZone]);
+}
+
+//#endregion
+export { parseHTTPDate, parseISODate, parseISODuration, parseISOTimeOnly, parseRFC2822Date, parseSQL };
+//# sourceMappingURL=regexParser.mjs.map

package/build/node_modules/.pnpm/luxon@3.5.0/node_modules/luxon/src/impl/regexParser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"regexParser.mjs","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/luxon@3.5.0/node_modules/luxon/src/impl/regexParser.js"],"sourcesContent":["import {\n  untruncateYear,\n  signedOffset,\n  parseInteger,\n  parseMillis,\n  isUndefined,\n  parseFloating,\n} from \"./util.js\";\nimport * as English from \"./english.js\";\nimport FixedOffsetZone from \"../zones/fixedOffsetZone.js\";\nimport IANAZone from \"../zones/IANAZone.js\";\n\n/*\n * This file handles parsing for well-specified formats. Here's how it works:\n * Two things go into parsing: a regex to match with and an extractor to take apart the groups in the match.\n * An extractor is just a function that takes a regex match array and returns a { year: ..., month: ... } object\n * parse() does the work of executing the regex and applying the extractor. It takes multiple regex/extractor pairs to try in sequence.\n * Extractors can take a \"cursor\" representing the offset in the match to look at. This makes it easy to combine extractors.\n * combineExtractors() does the work of combining them, keeping track of the cursor through multiple extractions.\n * Some extractions are super dumb and simpleParse and fromStrings help DRY them.\n */\n\nconst ianaRegex = /[A-Za-z_+-]{1,256}(?::?\\/[A-Za-z0-9_+-]{1,256}(?:\\/[A-Za-z0-9_+-]{1,256})?)?/;\n\nfunction combineRegexes(...regexes) {\n  const full = regexes.reduce((f, r) => f + r.source, \"\");\n  return RegExp(`^${full}$`);\n}\n\nfunction combineExtractors(...extractors) {\n  return (m) =>\n    extractors\n      .reduce(\n        ([mergedVals, mergedZone, cursor], ex) => {\n          const [val, zone, next] = ex(m, cursor);\n          return [{ ...mergedVals, ...val }, zone || mergedZone, next];\n        },\n        [{}, null, 1]\n      )\n      .slice(0, 2);\n}\n\nfunction parse(s, ...patterns) {\n  if (s == null) {\n    return [null, null];\n  }\n\n  for (const [regex, extractor] of patterns) {\n    const m = regex.exec(s);\n    if (m) {\n      return extractor(m);\n    }\n  }\n  return [null, null];\n}\n\nfunction simpleParse(...keys) {\n  return (match, cursor) => {\n    const ret = {};\n    let i;\n\n    for (i = 0; i < keys.length; i++) {\n      ret[keys[i]] = parseInteger(match[cursor + i]);\n    }\n    return [ret, null, cursor + i];\n  };\n}\n\n// ISO and SQL parsing\nconst offsetRegex = /(?:(Z)|([+-]\\d\\d)(?::?(\\d\\d))?)/;\nconst isoExtendedZone = `(?:${offsetRegex.source}?(?:\\\\[(${ianaRegex.source})\\\\])?)?`;\nconst isoTimeBaseRegex = /(\\d\\d)(?::?(\\d\\d)(?::?(\\d\\d)(?:[.,](\\d{1,30}))?)?)?/;\nconst isoTimeRegex = RegExp(`${isoTimeBaseRegex.source}${isoExtendedZone}`);\nconst isoTimeExtensionRegex = RegExp(`(?:T${isoTimeRegex.source})?`);\nconst isoYmdRegex = /([+-]\\d{6}|\\d{4})(?:-?(\\d\\d)(?:-?(\\d\\d))?)?/;\nconst isoWeekRegex = /(\\d{4})-?W(\\d\\d)(?:-?(\\d))?/;\nconst isoOrdinalRegex = /(\\d{4})-?(\\d{3})/;\nconst extractISOWeekData = simpleParse(\"weekYear\", \"weekNumber\", \"weekDay\");\nconst extractISOOrdinalData = simpleParse(\"year\", \"ordinal\");\nconst sqlYmdRegex = /(\\d{4})-(\\d\\d)-(\\d\\d)/; // dumbed-down version of the ISO one\nconst sqlTimeRegex = RegExp(\n  `${isoTimeBaseRegex.source} ?(?:${offsetRegex.source}|(${ianaRegex.source}))?`\n);\nconst sqlTimeExtensionRegex = RegExp(`(?: ${sqlTimeRegex.source})?`);\n\nfunction int(match, pos, fallback) {\n  const m = match[pos];\n  return isUndefined(m) ? fallback : parseInteger(m);\n}\n\nfunction extractISOYmd(match, cursor) {\n  const item = {\n    year: int(match, cursor),\n    month: int(match, cursor + 1, 1),\n    day: int(match, cursor + 2, 1),\n  };\n\n  return [item, null, cursor + 3];\n}\n\nfunction extractISOTime(match, cursor) {\n  const item = {\n    hours: int(match, cursor, 0),\n    minutes: int(match, cursor + 1, 0),\n    seconds: int(match, cursor + 2, 0),\n    milliseconds: parseMillis(match[cursor + 3]),\n  };\n\n  return [item, null, cursor + 4];\n}\n\nfunction extractISOOffset(match, cursor) {\n  const local = !match[cursor] && !match[cursor + 1],\n    fullOffset = signedOffset(match[cursor + 1], match[cursor + 2]),\n    zone = local ? null : FixedOffsetZone.instance(fullOffset);\n  return [{}, zone, cursor + 3];\n}\n\nfunction extractIANAZone(match, cursor) {\n  const zone = match[cursor] ? IANAZone.create(match[cursor]) : null;\n  return [{}, zone, cursor + 1];\n}\n\n// ISO time parsing\n\nconst isoTimeOnly = RegExp(`^T?${isoTimeBaseRegex.source}$`);\n\n// ISO duration parsing\n\nconst isoDuration =\n  /^-?P(?:(?:(-?\\d{1,20}(?:\\.\\d{1,20})?)Y)?(?:(-?\\d{1,20}(?:\\.\\d{1,20})?)M)?(?:(-?\\d{1,20}(?:\\.\\d{1,20})?)W)?(?:(-?\\d{1,20}(?:\\.\\d{1,20})?)D)?(?:T(?:(-?\\d{1,20}(?:\\.\\d{1,20})?)H)?(?:(-?\\d{1,20}(?:\\.\\d{1,20})?)M)?(?:(-?\\d{1,20})(?:[.,](-?\\d{1,20}))?S)?)?)$/;\n\nfunction extractISODuration(match) {\n  const [s, yearStr, monthStr, weekStr, dayStr, hourStr, minuteStr, secondStr, millisecondsStr] =\n    match;\n\n  const hasNegativePrefix = s[0] === \"-\";\n  const negativeSeconds = secondStr && secondStr[0] === \"-\";\n\n  const maybeNegate = (num, force = false) =>\n    num !== undefined && (force || (num && hasNegativePrefix)) ? -num : num;\n\n  return [\n    {\n      years: maybeNegate(parseFloating(yearStr)),\n      months: maybeNegate(parseFloating(monthStr)),\n      weeks: maybeNegate(parseFloating(weekStr)),\n      days: maybeNegate(parseFloating(dayStr)),\n      hours: maybeNegate(parseFloating(hourStr)),\n      minutes: maybeNegate(parseFloating(minuteStr)),\n      seconds: maybeNegate(parseFloating(secondStr), secondStr === \"-0\"),\n      milliseconds: maybeNegate(parseMillis(millisecondsStr), negativeSeconds),\n    },\n  ];\n}\n\n// These are a little braindead. EDT *should* tell us that we're in, say, America/New_York\n// and not just that we're in -240 *right now*. But since I don't think these are used that often\n// I'm just going to ignore that\nconst obsOffsets = {\n  GMT: 0,\n  EDT: -4 * 60,\n  EST: -5 * 60,\n  CDT: -5 * 60,\n  CST: -6 * 60,\n  MDT: -6 * 60,\n  MST: -7 * 60,\n  PDT: -7 * 60,\n  PST: -8 * 60,\n};\n\nfunction fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {\n  const result = {\n    year: yearStr.length === 2 ? untruncateYear(parseInteger(yearStr)) : parseInteger(yearStr),\n    month: English.monthsShort.indexOf(monthStr) + 1,\n    day: parseInteger(dayStr),\n    hour: parseInteger(hourStr),\n    minute: parseInteger(minuteStr),\n  };\n\n  if (secondStr) result.second = parseInteger(secondStr);\n  if (weekdayStr) {\n    result.weekday =\n      weekdayStr.length > 3\n        ? English.weekdaysLong.indexOf(weekdayStr) + 1\n        : English.weekdaysShort.indexOf(weekdayStr) + 1;\n  }\n\n  return result;\n}\n\n// RFC 2822/5322\nconst rfc2822 =\n  /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),\\s)?(\\d{1,2})\\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\\s(\\d{2,4})\\s(\\d\\d):(\\d\\d)(?::(\\d\\d))?\\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|(?:([+-]\\d\\d)(\\d\\d)))$/;\n\nfunction extractRFC2822(match) {\n  const [\n      ,\n      weekdayStr,\n      dayStr,\n      monthStr,\n      yearStr,\n      hourStr,\n      minuteStr,\n      secondStr,\n      obsOffset,\n      milOffset,\n      offHourStr,\n      offMinuteStr,\n    ] = match,\n    result = fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr);\n\n  let offset;\n  if (obsOffset) {\n    offset = obsOffsets[obsOffset];\n  } else if (milOffset) {\n    offset = 0;\n  } else {\n    offset = signedOffset(offHourStr, offMinuteStr);\n  }\n\n  return [result, new FixedOffsetZone(offset)];\n}\n\nfunction preprocessRFC2822(s) {\n  // Remove comments and folding whitespace and replace multiple-spaces with a single space\n  return s\n    .replace(/\\([^()]*\\)|[\\n\\t]/g, \" \")\n    .replace(/(\\s\\s+)/g, \" \")\n    .trim();\n}\n\n// http date\n\nconst rfc1123 =\n    /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\\d\\d) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\\d{4}) (\\d\\d):(\\d\\d):(\\d\\d) GMT$/,\n  rfc850 =\n    /^(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\\d\\d)-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\\d\\d) (\\d\\d):(\\d\\d):(\\d\\d) GMT$/,\n  ascii =\n    /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( \\d|\\d\\d) (\\d\\d):(\\d\\d):(\\d\\d) (\\d{4})$/;\n\nfunction extractRFC1123Or850(match) {\n  const [, weekdayStr, dayStr, monthStr, yearStr, hourStr, minuteStr, secondStr] = match,\n    result = fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr);\n  return [result, FixedOffsetZone.utcInstance];\n}\n\nfunction extractASCII(match) {\n  const [, weekdayStr, monthStr, dayStr, hourStr, minuteStr, secondStr, yearStr] = match,\n    result = fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr);\n  return [result, FixedOffsetZone.utcInstance];\n}\n\nconst isoYmdWithTimeExtensionRegex = combineRegexes(isoYmdRegex, isoTimeExtensionRegex);\nconst isoWeekWithTimeExtensionRegex = combineRegexes(isoWeekRegex, isoTimeExtensionRegex);\nconst isoOrdinalWithTimeExtensionRegex = combineRegexes(isoOrdinalRegex, isoTimeExtensionRegex);\nconst isoTimeCombinedRegex = combineRegexes(isoTimeRegex);\n\nconst extractISOYmdTimeAndOffset = combineExtractors(\n  extractISOYmd,\n  extractISOTime,\n  extractISOOffset,\n  extractIANAZone\n);\nconst extractISOWeekTimeAndOffset = combineExtractors(\n  extractISOWeekData,\n  extractISOTime,\n  extractISOOffset,\n  extractIANAZone\n);\nconst extractISOOrdinalDateAndTime = combineExtractors(\n  extractISOOrdinalData,\n  extractISOTime,\n  extractISOOffset,\n  extractIANAZone\n);\nconst extractISOTimeAndOffset = combineExtractors(\n  extractISOTime,\n  extractISOOffset,\n  extractIANAZone\n);\n\n/*\n * @private\n */\n\nexport function parseISODate(s) {\n  return parse(\n    s,\n    [isoYmdWithTimeExtensionRegex, extractISOYmdTimeAndOffset],\n    [isoWeekWithTimeExtensionRegex, extractISOWeekTimeAndOffset],\n    [isoOrdinalWithTimeExtensionRegex, extractISOOrdinalDateAndTime],\n    [isoTimeCombinedRegex, extractISOTimeAndOffset]\n  );\n}\n\nexport function parseRFC2822Date(s) {\n  return parse(preprocessRFC2822(s), [rfc2822, extractRFC2822]);\n}\n\nexport function parseHTTPDate(s) {\n  return parse(\n    s,\n    [rfc1123, extractRFC1123Or850],\n    [rfc850, extractRFC1123Or850],\n    [ascii, extractASCII]\n  );\n}\n\nexport function parseISODuration(s) {\n  return parse(s, [isoDuration, extractISODuration]);\n}\n\nconst extractISOTimeOnly = combineExtractors(extractISOTime);\n\nexport function parseISOTimeOnly(s) {\n  return parse(s, [isoTimeOnly, extractISOTimeOnly]);\n}\n\nconst sqlYmdWithTimeExtensionRegex = combineRegexes(sqlYmdRegex, sqlTimeExtensionRegex);\nconst sqlTimeCombinedRegex = combineRegexes(sqlTimeRegex);\n\nconst extractISOTimeOffsetAndIANAZone = combineExtractors(\n  extractISOTime,\n  extractISOOffset,\n  extractIANAZone\n);\n\nexport function parseSQL(s) {\n  return parse(\n    s,\n    [sqlYmdWithTimeExtensionRegex, extractISOYmdTimeAndOffset],\n    [sqlTimeCombinedRegex, extractISOTimeOffsetAndIANAZone]\n  );\n}\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/build/node_modules/.pnpm/luxon@3.5.0/node_modules/luxon/src/impl/tokenParser.js

@@ -0,0 +1,329 @@
+const require_errors = require('../errors.js');
+const require_IANAZone = require('../zones/IANAZone.js');
+const require_fixedOffsetZone = require('../zones/fixedOffsetZone.js');
+const require_digits = require('./digits.js');
+const require_util = require('./util.js');
+const require_formatter = require('./formatter.js');
+const require_datetime = require('../datetime.js');
+
+//#region ../../node_modules/.pnpm/luxon@3.5.0/node_modules/luxon/src/impl/tokenParser.js
+const MISSING_FTP = "missing Intl.DateTimeFormat.formatToParts support";
+function intUnit(regex, post = (i) => i) {
+	return {
+		regex,
+		deser: ([s]) => post(require_digits.parseDigits(s))
+	};
+}
+const spaceOrNBSP = `[ ${String.fromCharCode(160)}]`;
+const spaceOrNBSPRegExp = new RegExp(spaceOrNBSP, "g");
+function fixListRegex(s) {
+	return s.replace(/\./g, "\\.?").replace(spaceOrNBSPRegExp, spaceOrNBSP);
+}
+function stripInsensitivities(s) {
+	return s.replace(/\./g, "").replace(spaceOrNBSPRegExp, " ").toLowerCase();
+}
+function oneOf(strings, startIndex) {
+	if (strings === null) return null;
+	else return {
+		regex: RegExp(strings.map(fixListRegex).join("|")),
+		deser: ([s]) => strings.findIndex((i) => stripInsensitivities(s) === stripInsensitivities(i)) + startIndex
+	};
+}
+function offset(regex, groups) {
+	return {
+		regex,
+		deser: ([, h, m]) => require_util.signedOffset(h, m),
+		groups
+	};
+}
+function simple(regex) {
+	return {
+		regex,
+		deser: ([s]) => s
+	};
+}
+function escapeToken(value) {
+	return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
+}
+/**
+* @param token
+* @param {Locale} loc
+*/
+function unitForToken(token, loc) {
+	const one = require_digits.digitRegex(loc), two = require_digits.digitRegex(loc, "{2}"), three = require_digits.digitRegex(loc, "{3}"), four = require_digits.digitRegex(loc, "{4}"), six = require_digits.digitRegex(loc, "{6}"), oneOrTwo = require_digits.digitRegex(loc, "{1,2}"), oneToThree = require_digits.digitRegex(loc, "{1,3}"), oneToSix = require_digits.digitRegex(loc, "{1,6}"), oneToNine = require_digits.digitRegex(loc, "{1,9}"), twoToFour = require_digits.digitRegex(loc, "{2,4}"), fourToSix = require_digits.digitRegex(loc, "{4,6}"), literal = (t) => ({
+		regex: RegExp(escapeToken(t.val)),
+		deser: ([s]) => s,
+		literal: true
+	}), unitate = (t) => {
+		if (token.literal) return literal(t);
+		switch (t.val) {
+			case "G": return oneOf(loc.eras("short"), 0);
+			case "GG": return oneOf(loc.eras("long"), 0);
+			case "y": return intUnit(oneToSix);
+			case "yy": return intUnit(twoToFour, require_util.untruncateYear);
+			case "yyyy": return intUnit(four);
+			case "yyyyy": return intUnit(fourToSix);
+			case "yyyyyy": return intUnit(six);
+			case "M": return intUnit(oneOrTwo);
+			case "MM": return intUnit(two);
+			case "MMM": return oneOf(loc.months("short", true), 1);
+			case "MMMM": return oneOf(loc.months("long", true), 1);
+			case "L": return intUnit(oneOrTwo);
+			case "LL": return intUnit(two);
+			case "LLL": return oneOf(loc.months("short", false), 1);
+			case "LLLL": return oneOf(loc.months("long", false), 1);
+			case "d": return intUnit(oneOrTwo);
+			case "dd": return intUnit(two);
+			case "o": return intUnit(oneToThree);
+			case "ooo": return intUnit(three);
+			case "HH": return intUnit(two);
+			case "H": return intUnit(oneOrTwo);
+			case "hh": return intUnit(two);
+			case "h": return intUnit(oneOrTwo);
+			case "mm": return intUnit(two);
+			case "m": return intUnit(oneOrTwo);
+			case "q": return intUnit(oneOrTwo);
+			case "qq": return intUnit(two);
+			case "s": return intUnit(oneOrTwo);
+			case "ss": return intUnit(two);
+			case "S": return intUnit(oneToThree);
+			case "SSS": return intUnit(three);
+			case "u": return simple(oneToNine);
+			case "uu": return simple(oneOrTwo);
+			case "uuu": return intUnit(one);
+			case "a": return oneOf(loc.meridiems(), 0);
+			case "kkkk": return intUnit(four);
+			case "kk": return intUnit(twoToFour, require_util.untruncateYear);
+			case "W": return intUnit(oneOrTwo);
+			case "WW": return intUnit(two);
+			case "E":
+			case "c": return intUnit(one);
+			case "EEE": return oneOf(loc.weekdays("short", false), 1);
+			case "EEEE": return oneOf(loc.weekdays("long", false), 1);
+			case "ccc": return oneOf(loc.weekdays("short", true), 1);
+			case "cccc": return oneOf(loc.weekdays("long", true), 1);
+			case "Z":
+			case "ZZ": return offset(/* @__PURE__ */ new RegExp(`([+-]${oneOrTwo.source})(?::(${two.source}))?`), 2);
+			case "ZZZ": return offset(/* @__PURE__ */ new RegExp(`([+-]${oneOrTwo.source})(${two.source})?`), 2);
+			case "z": return simple(/[a-z_+-/]{1,256}?/i);
+			case " ": return simple(/[^\S\n\r]/);
+			default: return literal(t);
+		}
+	};
+	const unit = unitate(token) || { invalidReason: MISSING_FTP };
+	unit.token = token;
+	return unit;
+}
+const partTypeStyleToTokenVal = {
+	year: {
+		"2-digit": "yy",
+		numeric: "yyyyy"
+	},
+	month: {
+		numeric: "M",
+		"2-digit": "MM",
+		short: "MMM",
+		long: "MMMM"
+	},
+	day: {
+		numeric: "d",
+		"2-digit": "dd"
+	},
+	weekday: {
+		short: "EEE",
+		long: "EEEE"
+	},
+	dayperiod: "a",
+	dayPeriod: "a",
+	hour12: {
+		numeric: "h",
+		"2-digit": "hh"
+	},
+	hour24: {
+		numeric: "H",
+		"2-digit": "HH"
+	},
+	minute: {
+		numeric: "m",
+		"2-digit": "mm"
+	},
+	second: {
+		numeric: "s",
+		"2-digit": "ss"
+	},
+	timeZoneName: {
+		long: "ZZZZZ",
+		short: "ZZZ"
+	}
+};
+function tokenForPart(part, formatOpts, resolvedOpts) {
+	const { type, value } = part;
+	if (type === "literal") {
+		const isSpace = /^\s+$/.test(value);
+		return {
+			literal: !isSpace,
+			val: isSpace ? " " : value
+		};
+	}
+	const style = formatOpts[type];
+	let actualType = type;
+	if (type === "hour") if (formatOpts.hour12 != null) actualType = formatOpts.hour12 ? "hour12" : "hour24";
+	else if (formatOpts.hourCycle != null) if (formatOpts.hourCycle === "h11" || formatOpts.hourCycle === "h12") actualType = "hour12";
+	else actualType = "hour24";
+	else actualType = resolvedOpts.hour12 ? "hour12" : "hour24";
+	let val = partTypeStyleToTokenVal[actualType];
+	if (typeof val === "object") val = val[style];
+	if (val) return {
+		literal: false,
+		val
+	};
+}
+function buildRegex(units) {
+	return [`^${units.map((u) => u.regex).reduce((f, r) => `${f}(${r.source})`, "")}$`, units];
+}
+function match(input, regex, handlers) {
+	const matches = input.match(regex);
+	if (matches) {
+		const all = {};
+		let matchIndex = 1;
+		for (const i in handlers) if (require_util.hasOwnProperty(handlers, i)) {
+			const h = handlers[i], groups = h.groups ? h.groups + 1 : 1;
+			if (!h.literal && h.token) all[h.token.val[0]] = h.deser(matches.slice(matchIndex, matchIndex + groups));
+			matchIndex += groups;
+		}
+		return [matches, all];
+	} else return [matches, {}];
+}
+function dateTimeFromMatches(matches) {
+	const toField = (token) => {
+		switch (token) {
+			case "S": return "millisecond";
+			case "s": return "second";
+			case "m": return "minute";
+			case "h":
+			case "H": return "hour";
+			case "d": return "day";
+			case "o": return "ordinal";
+			case "L":
+			case "M": return "month";
+			case "y": return "year";
+			case "E":
+			case "c": return "weekday";
+			case "W": return "weekNumber";
+			case "k": return "weekYear";
+			case "q": return "quarter";
+			default: return null;
+		}
+	};
+	let zone = null;
+	let specificOffset;
+	if (!require_util.isUndefined(matches.z)) zone = require_IANAZone.default.create(matches.z);
+	if (!require_util.isUndefined(matches.Z)) {
+		if (!zone) zone = new require_fixedOffsetZone.default(matches.Z);
+		specificOffset = matches.Z;
+	}
+	if (!require_util.isUndefined(matches.q)) matches.M = (matches.q - 1) * 3 + 1;
+	if (!require_util.isUndefined(matches.h)) {
+		if (matches.h < 12 && matches.a === 1) matches.h += 12;
+		else if (matches.h === 12 && matches.a === 0) matches.h = 0;
+	}
+	if (matches.G === 0 && matches.y) matches.y = -matches.y;
+	if (!require_util.isUndefined(matches.u)) matches.S = require_util.parseMillis(matches.u);
+	return [
+		Object.keys(matches).reduce((r, k) => {
+			const f = toField(k);
+			if (f) r[f] = matches[k];
+			return r;
+		}, {}),
+		zone,
+		specificOffset
+	];
+}
+let dummyDateTimeCache = null;
+function getDummyDateTime() {
+	if (!dummyDateTimeCache) dummyDateTimeCache = require_datetime.default.fromMillis(1555555555555);
+	return dummyDateTimeCache;
+}
+function maybeExpandMacroToken(token, locale) {
+	if (token.literal) return token;
+	const tokens = formatOptsToTokens(require_formatter.default.macroTokenToFormatOpts(token.val), locale);
+	if (tokens == null || tokens.includes(void 0)) return token;
+	return tokens;
+}
+function expandMacroTokens(tokens, locale) {
+	return Array.prototype.concat(...tokens.map((t) => maybeExpandMacroToken(t, locale)));
+}
+/**
+* @private
+*/
+var TokenParser = class {
+	constructor(locale, format) {
+		this.locale = locale;
+		this.format = format;
+		this.tokens = expandMacroTokens(require_formatter.default.parseFormat(format), locale);
+		this.units = this.tokens.map((t) => unitForToken(t, locale));
+		this.disqualifyingUnit = this.units.find((t) => t.invalidReason);
+		if (!this.disqualifyingUnit) {
+			const [regexString, handlers] = buildRegex(this.units);
+			this.regex = RegExp(regexString, "i");
+			this.handlers = handlers;
+		}
+	}
+	explainFromTokens(input) {
+		if (!this.isValid) return {
+			input,
+			tokens: this.tokens,
+			invalidReason: this.invalidReason
+		};
+		else {
+			const [rawMatches, matches] = match(input, this.regex, this.handlers), [result, zone, specificOffset] = matches ? dateTimeFromMatches(matches) : [
+				null,
+				null,
+				void 0
+			];
+			if (require_util.hasOwnProperty(matches, "a") && require_util.hasOwnProperty(matches, "H")) throw new require_errors.ConflictingSpecificationError("Can't include meridiem when specifying 24-hour format");
+			return {
+				input,
+				tokens: this.tokens,
+				regex: this.regex,
+				rawMatches,
+				matches,
+				result,
+				zone,
+				specificOffset
+			};
+		}
+	}
+	get isValid() {
+		return !this.disqualifyingUnit;
+	}
+	get invalidReason() {
+		return this.disqualifyingUnit ? this.disqualifyingUnit.invalidReason : null;
+	}
+};
+function explainFromTokens(locale, input, format) {
+	return new TokenParser(locale, format).explainFromTokens(input);
+}
+function parseFromTokens(locale, input, format) {
+	const { result, zone, specificOffset, invalidReason } = explainFromTokens(locale, input, format);
+	return [
+		result,
+		zone,
+		specificOffset,
+		invalidReason
+	];
+}
+function formatOptsToTokens(formatOpts, locale) {
+	if (!formatOpts) return null;
+	const df = require_formatter.default.create(locale, formatOpts).dtFormatter(getDummyDateTime());
+	const parts = df.formatToParts();
+	const resolvedOpts = df.resolvedOptions();
+	return parts.map((p) => tokenForPart(p, formatOpts, resolvedOpts));
+}
+
+//#endregion
+exports.TokenParser = TokenParser;
+exports.expandMacroTokens = expandMacroTokens;
+exports.explainFromTokens = explainFromTokens;
+exports.formatOptsToTokens = formatOptsToTokens;
+exports.parseFromTokens = parseFromTokens;