@credo-ts/askar-to-drizzle-storage-migration 0.6.0-alpha-20251013113619 → 0.6.0-alpha-20251013151922

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

@@ -1,199 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,329 +0,0 @@
-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;