npm - @tenancy.nz/datepicker - Versions diffs - 1.3.4 - Mend

@tenancy.nz/datepicker 1.3.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (361) hide show

package/dist/esm/node_modules/.pnpm/@mui_x-date-pickers@8.27.0_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@em_f7106fb7eba50d62f3c82acfcf63ee91/node_modules/@mui/x-date-pickers/esm/internals/components/PickersModalDialog.js ADDED Viewed

@@ -0,0 +1,61 @@
+import _extends from '../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js';
+import DialogContent from '@mui/material/DialogContent';
+import Fade from '@mui/material/Fade';
+import MuiDialog, { dialogClasses } from '@mui/material/Dialog';
+import { styled } from '@mui/material/styles';
+import { DIALOG_WIDTH } from '../constants/dimensions.js';
+import { usePickerPrivateContext } from '../hooks/usePickerPrivateContext.js';
+import { jsx } from 'react/jsx-runtime';
+import { usePickerContext } from '../../hooks/usePickerContext.js';
+const PickersModalDialogRoot = styled(MuiDialog, {
+  slot: 'internal'
+})({
+  [`& .${dialogClasses.container}`]: {
+    outline: 0
+  },
+  [`& .${dialogClasses.paper}`]: {
+    outline: 0,
+    minWidth: DIALOG_WIDTH
+  }
+});
+const PickersModalDialogContent = styled(DialogContent, {
+  slot: 'internal'
+})({
+  '&:first-of-type': {
+    padding: 0
+  }
+});
+function PickersModalDialog(props) {
+  const {
+    children,
+    slots,
+    slotProps
+  } = props;
+  const {
+    open
+  } = usePickerContext();
+  const {
+    dismissViews,
+    onPopperExited
+  } = usePickerPrivateContext();
+  const Dialog = slots?.dialog ?? PickersModalDialogRoot;
+  const Transition = slots?.mobileTransition ?? Fade;
+  return /*#__PURE__*/jsx(Dialog, _extends({
+    open: open,
+    onClose: () => {
+      dismissViews();
+      onPopperExited?.();
+    }
+  }, slotProps?.dialog, {
+    TransitionComponent: Transition,
+    TransitionProps: slotProps?.mobileTransition,
+    PaperComponent: slots?.mobilePaper,
+    PaperProps: slotProps?.mobilePaper,
+    children: /*#__PURE__*/jsx(PickersModalDialogContent, {
+      children: children
+    })
+  }));
+}
+export { PickersModalDialog };

@@ -0,0 +1,118 @@
+import _extends from '../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js';
+import _objectWithoutPropertiesLoose from '../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js';
+import * as React from 'react';
+import { clsx } from '../../../../../../../clsx@2.1.1/node_modules/clsx/dist/clsx.js';
+import Typography from '@mui/material/Typography';
+import { useThemeProps, styled } from '@mui/material/styles';
+import { getPickersToolbarUtilityClass } from './pickersToolbarClasses.js';
+import { useToolbarOwnerState } from '../hooks/useToolbarOwnerState.js';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import composeClasses from '../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/composeClasses/composeClasses.js';
+import { shouldForwardProp } from '../../../../../../../@mui_system@7.3.1_@emotion_react@11.14.0_@types_react@19.1.9_react@18.3.1__@emotion_sty_acba54c86a0a45a77cd5d01171297ec0/node_modules/@mui/system/esm/createStyled/createStyled.js';
+const _excluded = ["children", "className", "classes", "toolbarTitle", "hidden", "titleId", "classes", "landscapeDirection"];
+const useUtilityClasses = classes => {
+  const slots = {
+    root: ['root'],
+    title: ['title'],
+    content: ['content']
+  };
+  return composeClasses(slots, getPickersToolbarUtilityClass, classes);
+};
+const PickersToolbarRoot = styled('div', {
+  name: 'MuiPickersToolbar',
+  slot: 'Root'
+})(({
+  theme
+}) => ({
+  display: 'flex',
+  flexDirection: 'column',
+  alignItems: 'flex-start',
+  justifyContent: 'space-between',
+  padding: theme.spacing(2, 3),
+  variants: [{
+    props: {
+      pickerOrientation: 'landscape'
+    },
+    style: {
+      height: 'auto',
+      maxWidth: 160,
+      padding: 16,
+      justifyContent: 'flex-start',
+      flexWrap: 'wrap'
+    }
+  }]
+}));
+const PickersToolbarContent = styled('div', {
+  name: 'MuiPickersToolbar',
+  slot: 'Content',
+  shouldForwardProp: prop => shouldForwardProp(prop) && prop !== 'landscapeDirection'
+})({
+  display: 'flex',
+  flexWrap: 'wrap',
+  width: '100%',
+  flex: 1,
+  justifyContent: 'space-between',
+  alignItems: 'center',
+  flexDirection: 'row',
+  variants: [{
+    props: {
+      pickerOrientation: 'landscape'
+    },
+    style: {
+      justifyContent: 'flex-start',
+      alignItems: 'flex-start',
+      flexDirection: 'column'
+    }
+  }, {
+    props: {
+      pickerOrientation: 'landscape',
+      landscapeDirection: 'row'
+    },
+    style: {
+      flexDirection: 'row'
+    }
+  }]
+});
+const PickersToolbar = /*#__PURE__*/React.forwardRef(function PickersToolbar(inProps, ref) {
+  const props = useThemeProps({
+    props: inProps,
+    name: 'MuiPickersToolbar'
+  });
+  const {
+      children,
+      className,
+      classes: classesProp,
+      toolbarTitle,
+      hidden,
+      titleId,
+      landscapeDirection
+    } = props,
+    other = _objectWithoutPropertiesLoose(props, _excluded);
+  const ownerState = useToolbarOwnerState();
+  const classes = useUtilityClasses(classesProp);
+  if (hidden) {
+    return null;
+  }
+  return /*#__PURE__*/jsxs(PickersToolbarRoot, _extends({
+    ref: ref,
+    className: clsx(classes.root, className),
+    ownerState: ownerState
+  }, other, {
+    children: [/*#__PURE__*/jsx(Typography, {
+      color: "text.secondary",
+      variant: "overline",
+      id: titleId,
+      className: classes.title,
+      children: toolbarTitle
+    }), /*#__PURE__*/jsx(PickersToolbarContent, {
+      className: classes.content,
+      ownerState: ownerState,
+      landscapeDirection: landscapeDirection,
+      children: children
+    })]
+  }));
+});
+if (process.env.NODE_ENV !== "production") PickersToolbar.displayName = "PickersToolbar";
+export { PickersToolbar };

@@ -0,0 +1,9 @@
+import generateUtilityClass from '../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/generateUtilityClass/generateUtilityClass.js';
+import generateUtilityClasses from '../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/generateUtilityClasses/generateUtilityClasses.js';
+function getPickersToolbarUtilityClass(slot) {
+  return generateUtilityClass('MuiPickersToolbar', slot);
+}
+generateUtilityClasses('MuiPickersToolbar', ['root', 'title', 'content']);
+export { getPickersToolbarUtilityClass };

@@ -0,0 +1,7 @@
+const DAY_SIZE = 36;
+const DAY_MARGIN = 2;
+const DIALOG_WIDTH = 320;
+const MAX_CALENDAR_HEIGHT = 280;
+const VIEW_HEIGHT = 336;
+export { DAY_MARGIN, DAY_SIZE, DIALOG_WIDTH, MAX_CALENDAR_HEIGHT, VIEW_HEIGHT };

@@ -0,0 +1,29 @@
+import * as React from 'react';
+import { usePickerAdapter } from '../../hooks/usePickerAdapter.js';
+function useNextMonthDisabled(month, {
+  disableFuture,
+  maxDate,
+  timezone
+}) {
+  const adapter = usePickerAdapter();
+  return React.useMemo(() => {
+    const now = adapter.date(undefined, timezone);
+    const lastEnabledMonth = adapter.startOfMonth(disableFuture && adapter.isBefore(now, maxDate) ? now : maxDate);
+    return !adapter.isAfter(lastEnabledMonth, month);
+  }, [disableFuture, maxDate, month, adapter, timezone]);
+}
+function usePreviousMonthDisabled(month, {
+  disablePast,
+  minDate,
+  timezone
+}) {
+  const adapter = usePickerAdapter();
+  return React.useMemo(() => {
+    const now = adapter.date(undefined, timezone);
+    const firstEnabledMonth = adapter.startOfMonth(disablePast && adapter.isAfter(now, minDate) ? now : minDate);
+    return !adapter.isBefore(firstEnabledMonth, month);
+  }, [disablePast, minDate, month, adapter, timezone]);
+}
+export { useNextMonthDisabled, usePreviousMonthDisabled };

@@ -0,0 +1,59 @@
+import * as React from 'react';
+import { usePickerAdapter } from '../../hooks/usePickerAdapter.js';
+import useControlled from '../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useControlled/useControlled.js';
+import useEventCallback from '../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useEventCallback/useEventCallback.js';
+/**
+ * Hooks controlling the value while making sure that:
+ * - The value returned by `onChange` always have the timezone of `props.value` or `props.defaultValue` if defined
+ * - The value rendered is always the one from `props.timezone` if defined
+ */
+const useControlledValue = ({
+  name,
+  timezone: timezoneProp,
+  value: valueProp,
+  defaultValue,
+  referenceDate,
+  onChange: onChangeProp,
+  valueManager
+}) => {
+  const adapter = usePickerAdapter();
+  const [valueWithInputTimezone, setValue] = useControlled({
+    name,
+    state: 'value',
+    controlled: valueProp,
+    default: defaultValue ?? valueManager.emptyValue
+  });
+  const inputTimezone = React.useMemo(() => valueManager.getTimezone(adapter, valueWithInputTimezone), [adapter, valueManager, valueWithInputTimezone]);
+  const setInputTimezone = useEventCallback(newValue => {
+    if (inputTimezone == null) {
+      return newValue;
+    }
+    return valueManager.setTimezone(adapter, inputTimezone, newValue);
+  });
+  const timezoneToRender = React.useMemo(() => {
+    if (timezoneProp) {
+      return timezoneProp;
+    }
+    if (inputTimezone) {
+      return inputTimezone;
+    }
+    if (referenceDate) {
+      return adapter.getTimezone(Array.isArray(referenceDate) ? referenceDate[0] : referenceDate);
+    }
+    return 'default';
+  }, [timezoneProp, inputTimezone, referenceDate, adapter]);
+  const valueWithTimezoneToRender = React.useMemo(() => valueManager.setTimezone(adapter, timezoneToRender, valueWithInputTimezone), [valueManager, adapter, timezoneToRender, valueWithInputTimezone]);
+  const handleValueChange = useEventCallback((newValue, ...otherParams) => {
+    const newValueWithInputTimezone = setInputTimezone(newValue);
+    setValue(newValueWithInputTimezone);
+    onChangeProp?.(newValueWithInputTimezone, ...otherParams);
+  });
+  return {
+    value: valueWithTimezoneToRender,
+    handleValueChange,
+    timezone: timezoneToRender
+  };
+};
+export { useControlledValue };

@@ -0,0 +1,91 @@
+import _extends from '../../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js';
+import _objectWithoutPropertiesLoose from '../../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js';
+import { PickerPopper } from '../../components/PickerPopper/PickerPopper.js';
+import { PickerProvider } from '../../components/PickerProvider.js';
+import { createNonRangePickerStepNavigation } from '../../utils/createNonRangePickerStepNavigation.js';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { usePicker } from '../usePicker/usePicker.js';
+import useSlotProps from '../../../../../../../../@mui_utils@7.3.7_@types_react@19.1.9_react@18.3.1/node_modules/@mui/utils/esm/useSlotProps/useSlotProps.js';
+import { PickersLayout } from '../../../PickersLayout/PickersLayout.js';
+const _excluded = ["props", "steps"],
+  _excluded2 = ["ownerState"];
+const useDesktopPicker = _ref => {
+  let {
+      props,
+      steps
+    } = _ref,
+    pickerParams = _objectWithoutPropertiesLoose(_ref, _excluded);
+  const {
+    slots,
+    slotProps: innerSlotProps,
+    label,
+    inputRef,
+    localeText
+  } = props;
+  const getStepNavigation = createNonRangePickerStepNavigation({
+    steps
+  });
+  const {
+    providerProps,
+    renderCurrentView,
+    ownerState
+  } = usePicker(_extends({}, pickerParams, {
+    props,
+    localeText,
+    autoFocusView: true,
+    viewContainerRole: 'dialog',
+    variant: 'desktop',
+    getStepNavigation
+  }));
+  const labelId = providerProps.privateContextValue.labelId;
+  const isToolbarHidden = innerSlotProps?.toolbar?.hidden ?? false;
+  const Field = slots.field;
+  const _useSlotProps = useSlotProps({
+      elementType: Field,
+      externalSlotProps: innerSlotProps?.field,
+      additionalProps: _extends({}, isToolbarHidden && {
+        id: labelId
+      }),
+      ownerState
+    }),
+    fieldProps = _objectWithoutPropertiesLoose(_useSlotProps, _excluded2);
+  const Layout = slots.layout ?? PickersLayout;
+  let labelledById = labelId;
+  if (isToolbarHidden) {
+    if (label) {
+      labelledById = `${labelId}-label`;
+    } else {
+      labelledById = undefined;
+    }
+  }
+  const slotProps = _extends({}, innerSlotProps, {
+    toolbar: _extends({}, innerSlotProps?.toolbar, {
+      titleId: labelId
+    }),
+    popper: _extends({
+      'aria-labelledby': labelledById
+    }, innerSlotProps?.popper)
+  });
+  const renderPicker = () => /*#__PURE__*/jsxs(PickerProvider, _extends({}, providerProps, {
+    children: [/*#__PURE__*/jsx(Field, _extends({}, fieldProps, {
+      slots: _extends({}, slots, fieldProps.slots),
+      slotProps: _extends({}, slotProps, fieldProps.slotProps),
+      inputRef: inputRef
+    })), /*#__PURE__*/jsx(PickerPopper, {
+      slots: slots,
+      slotProps: slotProps,
+      children: /*#__PURE__*/jsx(Layout, _extends({}, slotProps?.layout, {
+        slots: slots,
+        slotProps: slotProps,
+        children: renderCurrentView()
+      }))
+    })]
+  }));
+  if (process.env.NODE_ENV !== "production") renderPicker.displayName = "renderPicker";
+  return {
+    renderPicker
+  };
+};
+export { useDesktopPicker };

@@ -0,0 +1,258 @@
+import _extends from '../../../../../../../../@babel_runtime@7.28.6/node_modules/@babel/runtime/helpers/esm/extends.js';
+import { getDateSectionConfigFromFormatToken, doesSectionFormatHaveLeadingZeros, applyLocalizedDigits, cleanLeadingZeros, removeLocalizedDigits } from './useField.utils.js';
+const expandFormat = ({
+  adapter,
+  format
+}) => {
+  // Expand the provided format
+  let formatExpansionOverflow = 10;
+  let prevFormat = format;
+  let nextFormat = adapter.expandFormat(format);
+  while (nextFormat !== prevFormat) {
+    prevFormat = nextFormat;
+    nextFormat = adapter.expandFormat(prevFormat);
+    formatExpansionOverflow -= 1;
+    if (formatExpansionOverflow < 0) {
+      throw new Error('MUI X: The format expansion seems to be in an infinite loop. Please open an issue with the format passed to the component.');
+    }
+  }
+  return nextFormat;
+};
+const getEscapedPartsFromFormat = ({
+  adapter,
+  expandedFormat
+}) => {
+  const escapedParts = [];
+  const {
+    start: startChar,
+    end: endChar
+  } = adapter.escapedCharacters;
+  const regExp = new RegExp(`(\\${startChar}[^\\${endChar}]*\\${endChar})+`, 'g');
+  let match = null;
+  // eslint-disable-next-line no-cond-assign
+  while (match = regExp.exec(expandedFormat)) {
+    escapedParts.push({
+      start: match.index,
+      end: regExp.lastIndex - 1
+    });
+  }
+  return escapedParts;
+};
+const getSectionPlaceholder = (adapter, localeText, sectionConfig, sectionFormat) => {
+  switch (sectionConfig.type) {
+    case 'year':
+      {
+        return localeText.fieldYearPlaceholder({
+          digitAmount: adapter.formatByString(adapter.date(undefined, 'default'), sectionFormat).length,
+          format: sectionFormat
+        });
+      }
+    case 'month':
+      {
+        return localeText.fieldMonthPlaceholder({
+          contentType: sectionConfig.contentType,
+          format: sectionFormat
+        });
+      }
+    case 'day':
+      {
+        return localeText.fieldDayPlaceholder({
+          format: sectionFormat
+        });
+      }
+    case 'weekDay':
+      {
+        return localeText.fieldWeekDayPlaceholder({
+          contentType: sectionConfig.contentType,
+          format: sectionFormat
+        });
+      }
+    case 'hours':
+      {
+        return localeText.fieldHoursPlaceholder({
+          format: sectionFormat
+        });
+      }
+    case 'minutes':
+      {
+        return localeText.fieldMinutesPlaceholder({
+          format: sectionFormat
+        });
+      }
+    case 'seconds':
+      {
+        return localeText.fieldSecondsPlaceholder({
+          format: sectionFormat
+        });
+      }
+    case 'meridiem':
+      {
+        return localeText.fieldMeridiemPlaceholder({
+          format: sectionFormat
+        });
+      }
+    default:
+      {
+        return sectionFormat;
+      }
+  }
+};
+const createSection = ({
+  adapter,
+  date,
+  shouldRespectLeadingZeros,
+  localeText,
+  localizedDigits,
+  now,
+  token,
+  startSeparator
+}) => {
+  if (token === '') {
+    throw new Error('MUI X: Should not call `commitToken` with an empty token');
+  }
+  const sectionConfig = getDateSectionConfigFromFormatToken(adapter, token);
+  const hasLeadingZerosInFormat = doesSectionFormatHaveLeadingZeros(adapter, sectionConfig.contentType, sectionConfig.type, token);
+  const hasLeadingZerosInInput = shouldRespectLeadingZeros ? hasLeadingZerosInFormat : sectionConfig.contentType === 'digit';
+  const isValidDate = adapter.isValid(date);
+  let sectionValue = isValidDate ? adapter.formatByString(date, token) : '';
+  let maxLength = null;
+  if (hasLeadingZerosInInput) {
+    if (hasLeadingZerosInFormat) {
+      maxLength = sectionValue === '' ? adapter.formatByString(now, token).length : sectionValue.length;
+    } else {
+      if (sectionConfig.maxLength == null) {
+        throw new Error(`MUI X: The token ${token} should have a 'maxLength' property on it's adapter`);
+      }
+      maxLength = sectionConfig.maxLength;
+      if (isValidDate) {
+        sectionValue = applyLocalizedDigits(cleanLeadingZeros(removeLocalizedDigits(sectionValue, localizedDigits), maxLength), localizedDigits);
+      }
+    }
+  }
+  return _extends({}, sectionConfig, {
+    format: token,
+    maxLength,
+    value: sectionValue,
+    placeholder: getSectionPlaceholder(adapter, localeText, sectionConfig, token),
+    hasLeadingZerosInFormat,
+    hasLeadingZerosInInput,
+    startSeparator,
+    endSeparator: '',
+    modified: false
+  });
+};
+const buildSections = parameters => {
+  const {
+    adapter,
+    expandedFormat,
+    escapedParts
+  } = parameters;
+  const now = adapter.date(undefined);
+  const sections = [];
+  let startSeparator = '';
+  // This RegExp tests if the beginning of a string corresponds to a supported token
+  const validTokens = Object.keys(adapter.formatTokenMap).sort((a, b) => b.length - a.length); // Sort to put longest word first
+  const regExpFirstWordInFormat = /^([a-zA-Z]+)/;
+  const regExpWordOnlyComposedOfTokens = new RegExp(`^(${validTokens.join('|')})*$`);
+  const regExpFirstTokenInWord = new RegExp(`^(${validTokens.join('|')})`);
+  const getEscapedPartOfCurrentChar = i => escapedParts.find(escapeIndex => escapeIndex.start <= i && escapeIndex.end >= i);
+  let i = 0;
+  while (i < expandedFormat.length) {
+    const escapedPartOfCurrentChar = getEscapedPartOfCurrentChar(i);
+    const isEscapedChar = escapedPartOfCurrentChar != null;
+    const firstWordInFormat = regExpFirstWordInFormat.exec(expandedFormat.slice(i))?.[1];
+    // The first word in the format is only composed of tokens.
+    // We extract those tokens to create a new sections.
+    if (!isEscapedChar && firstWordInFormat != null && regExpWordOnlyComposedOfTokens.test(firstWordInFormat)) {
+      let word = firstWordInFormat;
+      while (word.length > 0) {
+        const firstWord = regExpFirstTokenInWord.exec(word)[1];
+        word = word.slice(firstWord.length);
+        sections.push(createSection(_extends({}, parameters, {
+          now,
+          token: firstWord,
+          startSeparator
+        })));
+        startSeparator = '';
+      }
+      i += firstWordInFormat.length;
+    }
+    // The remaining format does not start with a token,
+    // We take the first character and add it to the current section's end separator.
+    else {
+      const char = expandedFormat[i];
+      // If we are on the opening or closing character of an escaped part of the format,
+      // Then we ignore this character.
+      const isEscapeBoundary = isEscapedChar && escapedPartOfCurrentChar?.start === i || escapedPartOfCurrentChar?.end === i;
+      if (!isEscapeBoundary) {
+        if (sections.length === 0) {
+          startSeparator += char;
+        } else {
+          sections[sections.length - 1].endSeparator += char;
+          sections[sections.length - 1].isEndFormatSeparator = true;
+        }
+      }
+      i += 1;
+    }
+  }
+  if (sections.length === 0 && startSeparator.length > 0) {
+    sections.push({
+      type: 'empty',
+      contentType: 'letter',
+      maxLength: null,
+      format: '',
+      value: '',
+      placeholder: '',
+      hasLeadingZerosInFormat: false,
+      hasLeadingZerosInInput: false,
+      startSeparator,
+      endSeparator: '',
+      modified: false
+    });
+  }
+  return sections;
+};
+const postProcessSections = ({
+  isRtl,
+  formatDensity,
+  sections
+}) => {
+  return sections.map(section => {
+    const cleanSeparator = separator => {
+      let cleanedSeparator = separator;
+      if (isRtl && cleanedSeparator !== null && cleanedSeparator.includes(' ')) {
+        cleanedSeparator = `\u2069${cleanedSeparator}\u2066`;
+      }
+      if (formatDensity === 'spacious' && ['/', '.', '-'].includes(cleanedSeparator)) {
+        cleanedSeparator = ` ${cleanedSeparator} `;
+      }
+      return cleanedSeparator;
+    };
+    section.startSeparator = cleanSeparator(section.startSeparator);
+    section.endSeparator = cleanSeparator(section.endSeparator);
+    return section;
+  });
+};
+const buildSectionsFromFormat = parameters => {
+  let expandedFormat = expandFormat(parameters);
+  if (parameters.isRtl && parameters.enableAccessibleFieldDOMStructure) {
+    expandedFormat = expandedFormat.split(' ').reverse().join(' ');
+  }
+  const escapedParts = getEscapedPartsFromFormat(_extends({}, parameters, {
+    expandedFormat
+  }));
+  const sections = buildSections(_extends({}, parameters, {
+    expandedFormat,
+    escapedParts
+  }));
+  return postProcessSections(_extends({}, parameters, {
+    sections
+  }));
+};
+export { buildSectionsFromFormat };