\n// Get the document root in which the editor exists. This will\n// usually be the top-level `document`, but might be a [shadow\n// DOM](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Shadow_DOM)\n// root if the editor is inside one.\n\n\nprototypeAccessors$2.root.get = function () {\n var cached = this._root;\n\n if (cached == null) {\n for (var search = this.dom.parentNode; search; search = search.parentNode) {\n if (search.nodeType == 9 || search.nodeType == 11 && search.host) {\n if (!search.getSelection) {\n Object.getPrototypeOf(search).getSelection = function () {\n return document.getSelection();\n };\n }\n\n return this._root = search;\n }\n }\n }\n\n return cached || document;\n}; // :: ({left: number, top: number}) → ?{pos: number, inside: number}\n// Given a pair of viewport coordinates, return the document\n// position that corresponds to them. May return null if the given\n// coordinates aren't inside of the editor. When an object is\n// returned, its `pos` property is the position nearest to the\n// coordinates, and its `inside` property holds the position of the\n// inner node that the position falls inside of, or -1 if it is at\n// the top level, not in any node.\n\n\nEditorView.prototype.posAtCoords = function posAtCoords$1(coords) {\n return posAtCoords(this, coords);\n}; // :: (number, number) → {left: number, right: number, top: number, bottom: number}\n// Returns the viewport rectangle at a given document position.\n// `left` and `right` will be the same number, as this returns a\n// flat cursor-ish rectangle. If the position is between two things\n// that aren't directly adjacent, `side` determines which element is\n// used. When < 0, the element before the position is used,\n// otherwise the element after.\n\n\nEditorView.prototype.coordsAtPos = function coordsAtPos$1(pos, side) {\n if (side === void 0) side = 1;\n return coordsAtPos(this, pos, side);\n}; // :: (number, number) → {node: dom.Node, offset: number}\n// Find the DOM position that corresponds to the given document\n// position. When `side` is negative, find the position as close as\n// possible to the content before the position. When positive,\n// prefer positions close to the content after the position. When\n// zero, prefer as shallow a position as possible.\n//\n// Note that you should **not** mutate the editor's internal DOM,\n// only inspect it (and even that is usually not necessary).\n\n\nEditorView.prototype.domAtPos = function domAtPos(pos, side) {\n if (side === void 0) side = 0;\n return this.docView.domFromPos(pos, side);\n}; // :: (number) → ?dom.Node\n// Find the DOM node that represents the document node after the\n// given position. May return `null` when the position doesn't point\n// in front of a node or if the node is inside an opaque node view.\n//\n// This is intended to be able to call things like\n// `getBoundingClientRect` on that DOM node. Do **not** mutate the\n// editor DOM directly, or add styling this way, since that will be\n// immediately overriden by the editor as it redraws the node.\n\n\nEditorView.prototype.nodeDOM = function nodeDOM(pos) {\n var desc = this.docView.descAt(pos);\n return desc ? desc.nodeDOM : null;\n}; // :: (dom.Node, number, ?number) → number\n// Find the document position that corresponds to a given DOM\n// position. (Whenever possible, it is preferable to inspect the\n// document structure directly, rather than poking around in the\n// DOM, but sometimes—for example when interpreting an event\n// target—you don't have a choice.)\n//\n// The `bias` parameter can be used to influence which side of a DOM\n// node to use when the position is inside a leaf node.\n\n\nEditorView.prototype.posAtDOM = function posAtDOM(node, offset, bias) {\n if (bias === void 0) bias = -1;\n var pos = this.docView.posFromDOM(node, offset, bias);\n\n if (pos == null) {\n throw new RangeError(\"DOM position not inside the editor\");\n }\n\n return pos;\n}; // :: (union<\"up\", \"down\", \"left\", \"right\", \"forward\", \"backward\">, ?EditorState) → bool\n// Find out whether the selection is at the end of a textblock when\n// moving in a given direction. When, for example, given `\"left\"`,\n// it will return true if moving left from the current cursor\n// position would leave that position's parent textblock. Will apply\n// to the view's current state by default, but it is possible to\n// pass a different state.\n\n\nEditorView.prototype.endOfTextblock = function endOfTextblock$1(dir, state) {\n return endOfTextblock(this, state || this.state, dir);\n}; // :: ()\n// Removes the editor from the DOM and destroys all [node\n// views](#view.NodeView).\n\n\nEditorView.prototype.destroy = function destroy() {\n if (!this.docView) {\n return;\n }\n\n destroyInput(this);\n this.destroyPluginViews();\n\n if (this.mounted) {\n this.docView.update(this.state.doc, [], viewDecorations(this), this);\n this.dom.textContent = \"\";\n } else if (this.dom.parentNode) {\n this.dom.parentNode.removeChild(this.dom);\n }\n\n this.docView.destroy();\n this.docView = null;\n}; // Used for testing.\n\n\nEditorView.prototype.dispatchEvent = function dispatchEvent$1(event) {\n return dispatchEvent(this, event);\n}; // :: (Transaction)\n// Dispatch a transaction. Will call\n// [`dispatchTransaction`](#view.DirectEditorProps.dispatchTransaction)\n// when given, and otherwise defaults to applying the transaction to\n// the current state and calling\n// [`updateState`](#view.EditorView.updateState) with the result.\n// This method is bound to the view instance, so that it can be\n// easily passed around.\n\n\nEditorView.prototype.dispatch = function dispatch(tr) {\n var dispatchTransaction = this._props.dispatchTransaction;\n\n if (dispatchTransaction) {\n dispatchTransaction.call(this, tr);\n } else {\n this.updateState(this.state.apply(tr));\n }\n};\n\nObject.defineProperties(EditorView.prototype, prototypeAccessors$2);\n\nfunction computeDocDeco(view) {\n var attrs = Object.create(null);\n attrs.class = \"ProseMirror\";\n attrs.contenteditable = String(view.editable);\n view.someProp(\"attributes\", function (value) {\n if (typeof value == \"function\") {\n value = value(view.state);\n }\n\n if (value) {\n for (var attr in value) {\n if (attr == \"class\") {\n attrs.class += \" \" + value[attr];\n } else if (!attrs[attr] && attr != \"contenteditable\" && attr != \"nodeName\") {\n attrs[attr] = String(value[attr]);\n }\n }\n }\n });\n return [Decoration.node(0, view.state.doc.content.size, attrs)];\n}\n\nfunction updateCursorWrapper(view) {\n if (view.markCursor) {\n var dom = document.createElement(\"img\");\n dom.setAttribute(\"mark-placeholder\", \"true\");\n view.cursorWrapper = {\n dom: dom,\n deco: Decoration.widget(view.state.selection.head, dom, {\n raw: true,\n marks: view.markCursor\n })\n };\n } else {\n view.cursorWrapper = null;\n }\n}\n\nfunction getEditable(view) {\n return !view.someProp(\"editable\", function (value) {\n return value(view.state) === false;\n });\n}\n\nfunction selectionContextChanged(sel1, sel2) {\n var depth = Math.min(sel1.$anchor.sharedDepth(sel1.head), sel2.$anchor.sharedDepth(sel2.head));\n return sel1.$anchor.start(depth) != sel2.$anchor.start(depth);\n}\n\nfunction buildNodeViews(view) {\n var result = {};\n view.someProp(\"nodeViews\", function (obj) {\n for (var prop in obj) {\n if (!Object.prototype.hasOwnProperty.call(result, prop)) {\n result[prop] = obj[prop];\n }\n }\n });\n return result;\n}\n\nfunction changedNodeViews(a, b) {\n var nA = 0,\n nB = 0;\n\n for (var prop in a) {\n if (a[prop] != b[prop]) {\n return true;\n }\n\n nA++;\n }\n\n for (var _ in b) {\n nB++;\n }\n\n return nA != nB;\n} // EditorProps:: interface\n//\n// Props are configuration values that can be passed to an editor view\n// or included in a plugin. This interface lists the supported props.\n//\n// The various event-handling functions may all return `true` to\n// indicate that they handled the given event. The view will then take\n// care to call `preventDefault` on the event, except with\n// `handleDOMEvents`, where the handler itself is responsible for that.\n//\n// How a prop is resolved depends on the prop. Handler functions are\n// called one at a time, starting with the base props and then\n// searching through the plugins (in order of appearance) until one of\n// them returns true. For some props, the first plugin that yields a\n// value gets precedence.\n//\n// handleDOMEvents:: ?Object<(view: EditorView, event: dom.Event) → bool>\n// Can be an object mapping DOM event type names to functions that\n// handle them. Such functions will be called before any handling\n// ProseMirror does of events fired on the editable DOM element.\n// Contrary to the other event handling props, when returning true\n// from such a function, you are responsible for calling\n// `preventDefault` yourself (or not, if you want to allow the\n// default behavior).\n//\n// handleKeyDown:: ?(view: EditorView, event: dom.KeyboardEvent) → bool\n// Called when the editor receives a `keydown` event.\n//\n// handleKeyPress:: ?(view: EditorView, event: dom.KeyboardEvent) → bool\n// Handler for `keypress` events.\n//\n// handleTextInput:: ?(view: EditorView, from: number, to: number, text: string) → bool\n// Whenever the user directly input text, this handler is called\n// before the input is applied. If it returns `true`, the default\n// behavior of actually inserting the text is suppressed.\n//\n// handleClickOn:: ?(view: EditorView, pos: number, node: Node, nodePos: number, event: dom.MouseEvent, direct: bool) → bool\n// Called for each node around a click, from the inside out. The\n// `direct` flag will be true for the inner node.\n//\n// handleClick:: ?(view: EditorView, pos: number, event: dom.MouseEvent) → bool\n// Called when the editor is clicked, after `handleClickOn` handlers\n// have been called.\n//\n// handleDoubleClickOn:: ?(view: EditorView, pos: number, node: Node, nodePos: number, event: dom.MouseEvent, direct: bool) → bool\n// Called for each node around a double click.\n//\n// handleDoubleClick:: ?(view: EditorView, pos: number, event: dom.MouseEvent) → bool\n// Called when the editor is double-clicked, after `handleDoubleClickOn`.\n//\n// handleTripleClickOn:: ?(view: EditorView, pos: number, node: Node, nodePos: number, event: dom.MouseEvent, direct: bool) → bool\n// Called for each node around a triple click.\n//\n// handleTripleClick:: ?(view: EditorView, pos: number, event: dom.MouseEvent) → bool\n// Called when the editor is triple-clicked, after `handleTripleClickOn`.\n//\n// handlePaste:: ?(view: EditorView, event: dom.ClipboardEvent, slice: Slice) → bool\n// Can be used to override the behavior of pasting. `slice` is the\n// pasted content parsed by the editor, but you can directly access\n// the event to get at the raw content.\n//\n// handleDrop:: ?(view: EditorView, event: dom.Event, slice: Slice, moved: bool) → bool\n// Called when something is dropped on the editor. `moved` will be\n// true if this drop moves from the current selection (which should\n// thus be deleted).\n//\n// handleScrollToSelection:: ?(view: EditorView) → bool\n// Called when the view, after updating its state, tries to scroll\n// the selection into view. A handler function may return false to\n// indicate that it did not handle the scrolling and further\n// handlers or the default behavior should be tried.\n//\n// createSelectionBetween:: ?(view: EditorView, anchor: ResolvedPos, head: ResolvedPos) → ?Selection\n// Can be used to override the way a selection is created when\n// reading a DOM selection between the given anchor and head.\n//\n// domParser:: ?DOMParser\n// The [parser](#model.DOMParser) to use when reading editor changes\n// from the DOM. Defaults to calling\n// [`DOMParser.fromSchema`](#model.DOMParser^fromSchema) on the\n// editor's schema.\n//\n// transformPastedHTML:: ?(html: string) → string\n// Can be used to transform pasted HTML text, _before_ it is parsed,\n// for example to clean it up.\n//\n// clipboardParser:: ?DOMParser\n// The [parser](#model.DOMParser) to use when reading content from\n// the clipboard. When not given, the value of the\n// [`domParser`](#view.EditorProps.domParser) prop is used.\n//\n// transformPastedText:: ?(text: string, plain: bool) → string\n// Transform pasted plain text. The `plain` flag will be true when\n// the text is pasted as plain text.\n//\n// clipboardTextParser:: ?(text: string, $context: ResolvedPos, plain: bool) → Slice\n// A function to parse text from the clipboard into a document\n// slice. Called after\n// [`transformPastedText`](#view.EditorProps.transformPastedText).\n// The default behavior is to split the text into lines, wrap them\n// in `` tags, and call\n// [`clipboardParser`](#view.EditorProps.clipboardParser) on it.\n// The `plain` flag will be true when the text is pasted as plain text.\n//\n// transformPasted:: ?(Slice) → Slice\n// Can be used to transform pasted content before it is applied to\n// the document.\n//\n// nodeViews:: ?Object<(node: Node, view: EditorView, getPos: () → number, decorations: [Decoration], innerDecorations: DecorationSource) → NodeView>\n// Allows you to pass custom rendering and behavior logic for nodes\n// and marks. Should map node and mark names to constructor\n// functions that produce a [`NodeView`](#view.NodeView) object\n// implementing the node's display behavior. For nodes, the third\n// argument `getPos` is a function that can be called to get the\n// node's current position, which can be useful when creating\n// transactions to update it. For marks, the third argument is a\n// boolean that indicates whether the mark's content is inline.\n//\n// `decorations` is an array of node or inline decorations that are\n// active around the node. They are automatically drawn in the\n// normal way, and you will usually just want to ignore this, but\n// they can also be used as a way to provide context information to\n// the node view without adding it to the document itself.\n//\n// `innerDecorations` holds the decorations for the node's content.\n// You can safely ignore this if your view has no content or a\n// `contentDOM` property, since the editor will draw the decorations\n// on the content. But if you, for example, want to create a nested\n// editor with the content, it may make sense to provide it with the\n// inner decorations.\n//\n// clipboardSerializer:: ?DOMSerializer\n// The DOM serializer to use when putting content onto the\n// clipboard. If not given, the result of\n// [`DOMSerializer.fromSchema`](#model.DOMSerializer^fromSchema)\n// will be used.\n//\n// clipboardTextSerializer:: ?(Slice) → string\n// A function that will be called to get the text for the current\n// selection when copying text to the clipboard. By default, the\n// editor will use [`textBetween`](#model.Node.textBetween) on the\n// selected range.\n//\n// decorations:: ?(state: EditorState) → ?DecorationSource\n// A set of [document decorations](#view.Decoration) to show in the\n// view.\n//\n// editable:: ?(state: EditorState) → bool\n// When this returns false, the content of the view is not directly\n// editable.\n//\n// attributes:: ?union, (EditorState) → ?Object>\n// Control the DOM attributes of the editable element. May be either\n// an object or a function going from an editor state to an object.\n// By default, the element will get a class `\"ProseMirror\"`, and\n// will have its `contentEditable` attribute determined by the\n// [`editable` prop](#view.EditorProps.editable). Additional classes\n// provided here will be added to the class. For other attributes,\n// the value provided first (as in\n// [`someProp`](#view.EditorView.someProp)) will be used.\n//\n// scrollThreshold:: ?union\n// Determines the distance (in pixels) between the cursor and the\n// end of the visible viewport at which point, when scrolling the\n// cursor into view, scrolling takes place. Defaults to 0.\n//\n// scrollMargin:: ?union\n// Determines the extra space (in pixels) that is left above or\n// below the cursor when it is scrolled into view. Defaults to 5.\n// DirectEditorProps:: interface extends EditorProps\n//\n// The props object given directly to the editor view supports two\n// fields that can't be used in plugins:\n//\n// state:: EditorState\n// The current state of the editor.\n//\n// dispatchTransaction:: ?(tr: Transaction)\n// The callback over which to send transactions (state updates)\n// produced by the view. If you specify this, you probably want to\n// make sure this ends up calling the view's\n// [`updateState`](#view.EditorView.updateState) method with a new\n// state that has the transaction\n// [applied](#state.EditorState.apply). The callback will be bound to have\n// the view instance as its `this` binding.\n\n\nexport { Decoration, DecorationSet, EditorView, endComposition as __endComposition, parseFromClipboard as __parseFromClipboard, serializeForClipboard as __serializeForClipboard };","/* eslint-disable max-classes-per-file */\nexport class DuplicateContactException extends Error {\n constructor(data) {\n super('DUPLICATE_CONTACT');\n this.data = data;\n this.name = 'DuplicateContactException';\n }\n}\nexport class ExceptionWithMessage extends Error {\n constructor(data) {\n super('ERROR_WITH_MESSAGE');\n this.data = data;\n this.name = 'ExceptionWithMessage';\n }\n}\n","export default function assign(target, dirtyObject) {\n if (target == null) {\n throw new TypeError('assign requires that input parameter not be null or undefined');\n }\n\n dirtyObject = dirtyObject || {};\n\n for (var property in dirtyObject) {\n if (dirtyObject.hasOwnProperty(property)) {\n target[property] = dirtyObject[property];\n }\n }\n\n return target;\n}","import getTimezoneOffsetInMilliseconds from \"../_lib/getTimezoneOffsetInMilliseconds/index.js\";\nimport startOfDay from \"../startOfDay/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\nvar MILLISECONDS_IN_DAY = 86400000;\n/**\n * @name differenceInCalendarDays\n * @category Day Helpers\n * @summary Get the number of calendar days between the given dates.\n *\n * @description\n * Get the number of calendar days between the given dates. This means that the times are removed\n * from the dates and then the difference in days is calculated.\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * @param {Date|Number} dateLeft - the later date\n * @param {Date|Number} dateRight - the earlier date\n * @returns {Number} the number of calendar days\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // How many calendar days are between\n * // 2 July 2011 23:00:00 and 2 July 2012 00:00:00?\n * var result = differenceInCalendarDays(\n * new Date(2012, 6, 2, 0, 0),\n * new Date(2011, 6, 2, 23, 0)\n * )\n * //=> 366\n * // How many calendar days are between\n * // 2 July 2011 23:59:00 and 3 July 2011 00:01:00?\n * var result = differenceInCalendarDays(\n * new Date(2011, 6, 3, 0, 1),\n * new Date(2011, 6, 2, 23, 59)\n * )\n * //=> 1\n */\n\nexport default function differenceInCalendarDays(dirtyDateLeft, dirtyDateRight) {\n requiredArgs(2, arguments);\n var startOfDayLeft = startOfDay(dirtyDateLeft);\n var startOfDayRight = startOfDay(dirtyDateRight);\n var timestampLeft = startOfDayLeft.getTime() - getTimezoneOffsetInMilliseconds(startOfDayLeft);\n var timestampRight = startOfDayRight.getTime() - getTimezoneOffsetInMilliseconds(startOfDayRight); // Round the number of days to the nearest integer\n // because the number of milliseconds in a day is not constant\n // (e.g. it's different in the day of the daylight saving time clock shift)\n\n return Math.round((timestampLeft - timestampRight) / MILLISECONDS_IN_DAY);\n}","import toDate from \"../toDate/index.js\";\nimport differenceInCalendarDays from \"../differenceInCalendarDays/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\"; // Like `compareAsc` but uses local time not UTC, which is needed\n// for accurate equality comparisons of UTC timestamps that end up\n// having the same representation in local time, e.g. one hour before\n// DST ends vs. the instant that DST ends.\n\nfunction compareLocalAsc(dateLeft, dateRight) {\n var diff = dateLeft.getFullYear() - dateRight.getFullYear() || dateLeft.getMonth() - dateRight.getMonth() || dateLeft.getDate() - dateRight.getDate() || dateLeft.getHours() - dateRight.getHours() || dateLeft.getMinutes() - dateRight.getMinutes() || dateLeft.getSeconds() - dateRight.getSeconds() || dateLeft.getMilliseconds() - dateRight.getMilliseconds();\n\n if (diff < 0) {\n return -1;\n } else if (diff > 0) {\n return 1; // Return 0 if diff is 0; return NaN if diff is NaN\n } else {\n return diff;\n }\n}\n/**\n * @name differenceInDays\n * @category Day Helpers\n * @summary Get the number of full days between the given dates.\n *\n * @description\n * Get the number of full day periods between two dates. Fractional days are\n * truncated towards zero.\n *\n * One \"full day\" is the distance between a local time in one day to the same\n * local time on the next or previous day. A full day can sometimes be less than\n * or more than 24 hours if a daylight savings change happens between two dates.\n *\n * To ignore DST and only measure exact 24-hour periods, use this instead:\n * `Math.floor(differenceInHours(dateLeft, dateRight)/24)|0`.\n *\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * @param {Date|Number} dateLeft - the later date\n * @param {Date|Number} dateRight - the earlier date\n * @returns {Number} the number of full days according to the local timezone\n * @throws {TypeError} 2 arguments required\n *\n * @example\n * // How many full days are between\n * // 2 July 2011 23:00:00 and 2 July 2012 00:00:00?\n * var result = differenceInDays(\n * new Date(2012, 6, 2, 0, 0),\n * new Date(2011, 6, 2, 23, 0)\n * )\n * //=> 365\n * // How many full days are between\n * // 2 July 2011 23:59:00 and 3 July 2011 00:01:00?\n * var result = differenceInDays(\n * new Date(2011, 6, 3, 0, 1),\n * new Date(2011, 6, 2, 23, 59)\n * )\n * //=> 0\n * // How many full days are between\n * // 1 March 2020 0:00 and 1 June 2020 0:00 ?\n * // Note: because local time is used, the\n * // result will always be 92 days, even in\n * // time zones where DST starts and the\n * // period has only 92*24-1 hours.\n * var result = differenceInDays(\n * new Date(2020, 5, 1),\n * new Date(2020, 2, 1)\n * )\n//=> 92\n */\n\n\nexport default function differenceInDays(dirtyDateLeft, dirtyDateRight) {\n requiredArgs(2, arguments);\n var dateLeft = toDate(dirtyDateLeft);\n var dateRight = toDate(dirtyDateRight);\n var sign = compareLocalAsc(dateLeft, dateRight);\n var difference = Math.abs(differenceInCalendarDays(dateLeft, dateRight));\n dateLeft.setDate(dateLeft.getDate() - sign * difference); // Math.abs(diff in full days - diff in calendar days) === 1 if last calendar day is not full\n // If so, result must be decreased by 1 in absolute value\n\n var isLastDayNotFull = compareLocalAsc(dateLeft, dateRight) === -sign;\n var result = sign * (difference - isLastDayNotFull); // Prevent negative zero\n\n return result === 0 ? 0 : result;\n}","import keyboardEventListenerMixins from 'shared/mixins/keyboardEventListenerMixins';\n\nexport default {\n mixins: [keyboardEventListenerMixins],\n methods: {\n moveSelectionUp() {\n if (!this.selectedIndex) {\n this.selectedIndex = this.items.length - 1;\n } else {\n this.selectedIndex -= 1;\n }\n this.adjustScroll();\n },\n moveSelectionDown() {\n if (this.selectedIndex === this.items.length - 1) {\n this.selectedIndex = 0;\n } else {\n this.selectedIndex += 1;\n }\n this.adjustScroll();\n },\n getKeyboardEvents() {\n return {\n ArrowUp: {\n action: e => {\n this.moveSelectionUp();\n e.preventDefault();\n },\n allowOnFocusedInput: true,\n },\n 'Control+KeyP': {\n action: e => {\n this.moveSelectionUp();\n e.preventDefault();\n },\n allowOnFocusedInput: true,\n },\n ArrowDown: {\n action: e => {\n this.moveSelectionDown();\n e.preventDefault();\n },\n allowOnFocusedInput: true,\n },\n 'Control+KeyN': {\n action: e => {\n this.moveSelectionDown();\n e.preventDefault();\n },\n allowOnFocusedInput: true,\n },\n Enter: {\n action: e => {\n this.onSelect();\n e.preventDefault();\n },\n allowOnFocusedInput: true,\n },\n };\n },\n },\n};\n","import toInteger from \"../toInteger/index.js\";\nimport toDate from \"../../toDate/index.js\";\nimport requiredArgs from \"../requiredArgs/index.js\"; // This function will be a part of public API when UTC function will be implemented.\n// See issue: https://github.com/date-fns/date-fns/issues/376\n\nexport default function setUTCDay(dirtyDate, dirtyDay, dirtyOptions) {\n requiredArgs(2, arguments);\n var options = dirtyOptions || {};\n var locale = options.locale;\n var localeWeekStartsOn = locale && locale.options && locale.options.weekStartsOn;\n var defaultWeekStartsOn = localeWeekStartsOn == null ? 0 : toInteger(localeWeekStartsOn);\n var weekStartsOn = options.weekStartsOn == null ? defaultWeekStartsOn : toInteger(options.weekStartsOn); // Test if weekStartsOn is between 0 and 6 _and_ is not NaN\n\n if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {\n throw new RangeError('weekStartsOn must be between 0 and 6 inclusively');\n }\n\n var date = toDate(dirtyDate);\n var day = toInteger(dirtyDay);\n var currentDay = date.getUTCDay();\n var remainder = day % 7;\n var dayIndex = (remainder + 7) % 7;\n var diff = (dayIndex < weekStartsOn ? 7 : 0) + day - currentDay;\n date.setUTCDate(date.getUTCDate() + diff);\n return date;\n}","import getUTCWeekYear from \"../../../_lib/getUTCWeekYear/index.js\";\nimport setUTCDay from \"../../../_lib/setUTCDay/index.js\";\nimport setUTCISODay from \"../../../_lib/setUTCISODay/index.js\";\nimport setUTCISOWeek from \"../../../_lib/setUTCISOWeek/index.js\";\nimport setUTCWeek from \"../../../_lib/setUTCWeek/index.js\";\nimport startOfUTCISOWeek from \"../../../_lib/startOfUTCISOWeek/index.js\";\nimport startOfUTCWeek from \"../../../_lib/startOfUTCWeek/index.js\";\nvar MILLISECONDS_IN_HOUR = 3600000;\nvar MILLISECONDS_IN_MINUTE = 60000;\nvar MILLISECONDS_IN_SECOND = 1000;\nvar numericPatterns = {\n month: /^(1[0-2]|0?\\d)/,\n // 0 to 12\n date: /^(3[0-1]|[0-2]?\\d)/,\n // 0 to 31\n dayOfYear: /^(36[0-6]|3[0-5]\\d|[0-2]?\\d?\\d)/,\n // 0 to 366\n week: /^(5[0-3]|[0-4]?\\d)/,\n // 0 to 53\n hour23h: /^(2[0-3]|[0-1]?\\d)/,\n // 0 to 23\n hour24h: /^(2[0-4]|[0-1]?\\d)/,\n // 0 to 24\n hour11h: /^(1[0-1]|0?\\d)/,\n // 0 to 11\n hour12h: /^(1[0-2]|0?\\d)/,\n // 0 to 12\n minute: /^[0-5]?\\d/,\n // 0 to 59\n second: /^[0-5]?\\d/,\n // 0 to 59\n singleDigit: /^\\d/,\n // 0 to 9\n twoDigits: /^\\d{1,2}/,\n // 0 to 99\n threeDigits: /^\\d{1,3}/,\n // 0 to 999\n fourDigits: /^\\d{1,4}/,\n // 0 to 9999\n anyDigitsSigned: /^-?\\d+/,\n singleDigitSigned: /^-?\\d/,\n // 0 to 9, -0 to -9\n twoDigitsSigned: /^-?\\d{1,2}/,\n // 0 to 99, -0 to -99\n threeDigitsSigned: /^-?\\d{1,3}/,\n // 0 to 999, -0 to -999\n fourDigitsSigned: /^-?\\d{1,4}/ // 0 to 9999, -0 to -9999\n\n};\nvar timezonePatterns = {\n basicOptionalMinutes: /^([+-])(\\d{2})(\\d{2})?|Z/,\n basic: /^([+-])(\\d{2})(\\d{2})|Z/,\n basicOptionalSeconds: /^([+-])(\\d{2})(\\d{2})((\\d{2}))?|Z/,\n extended: /^([+-])(\\d{2}):(\\d{2})|Z/,\n extendedOptionalSeconds: /^([+-])(\\d{2}):(\\d{2})(:(\\d{2}))?|Z/\n};\n\nfunction parseNumericPattern(pattern, string, valueCallback) {\n var matchResult = string.match(pattern);\n\n if (!matchResult) {\n return null;\n }\n\n var value = parseInt(matchResult[0], 10);\n return {\n value: valueCallback ? valueCallback(value) : value,\n rest: string.slice(matchResult[0].length)\n };\n}\n\nfunction parseTimezonePattern(pattern, string) {\n var matchResult = string.match(pattern);\n\n if (!matchResult) {\n return null;\n } // Input is 'Z'\n\n\n if (matchResult[0] === 'Z') {\n return {\n value: 0,\n rest: string.slice(1)\n };\n }\n\n var sign = matchResult[1] === '+' ? 1 : -1;\n var hours = matchResult[2] ? parseInt(matchResult[2], 10) : 0;\n var minutes = matchResult[3] ? parseInt(matchResult[3], 10) : 0;\n var seconds = matchResult[5] ? parseInt(matchResult[5], 10) : 0;\n return {\n value: sign * (hours * MILLISECONDS_IN_HOUR + minutes * MILLISECONDS_IN_MINUTE + seconds * MILLISECONDS_IN_SECOND),\n rest: string.slice(matchResult[0].length)\n };\n}\n\nfunction parseAnyDigitsSigned(string, valueCallback) {\n return parseNumericPattern(numericPatterns.anyDigitsSigned, string, valueCallback);\n}\n\nfunction parseNDigits(n, string, valueCallback) {\n switch (n) {\n case 1:\n return parseNumericPattern(numericPatterns.singleDigit, string, valueCallback);\n\n case 2:\n return parseNumericPattern(numericPatterns.twoDigits, string, valueCallback);\n\n case 3:\n return parseNumericPattern(numericPatterns.threeDigits, string, valueCallback);\n\n case 4:\n return parseNumericPattern(numericPatterns.fourDigits, string, valueCallback);\n\n default:\n return parseNumericPattern(new RegExp('^\\\\d{1,' + n + '}'), string, valueCallback);\n }\n}\n\nfunction parseNDigitsSigned(n, string, valueCallback) {\n switch (n) {\n case 1:\n return parseNumericPattern(numericPatterns.singleDigitSigned, string, valueCallback);\n\n case 2:\n return parseNumericPattern(numericPatterns.twoDigitsSigned, string, valueCallback);\n\n case 3:\n return parseNumericPattern(numericPatterns.threeDigitsSigned, string, valueCallback);\n\n case 4:\n return parseNumericPattern(numericPatterns.fourDigitsSigned, string, valueCallback);\n\n default:\n return parseNumericPattern(new RegExp('^-?\\\\d{1,' + n + '}'), string, valueCallback);\n }\n}\n\nfunction dayPeriodEnumToHours(enumValue) {\n switch (enumValue) {\n case 'morning':\n return 4;\n\n case 'evening':\n return 17;\n\n case 'pm':\n case 'noon':\n case 'afternoon':\n return 12;\n\n case 'am':\n case 'midnight':\n case 'night':\n default:\n return 0;\n }\n}\n\nfunction normalizeTwoDigitYear(twoDigitYear, currentYear) {\n var isCommonEra = currentYear > 0; // Absolute number of the current year:\n // 1 -> 1 AC\n // 0 -> 1 BC\n // -1 -> 2 BC\n\n var absCurrentYear = isCommonEra ? currentYear : 1 - currentYear;\n var result;\n\n if (absCurrentYear <= 50) {\n result = twoDigitYear || 100;\n } else {\n var rangeEnd = absCurrentYear + 50;\n var rangeEndCentury = Math.floor(rangeEnd / 100) * 100;\n var isPreviousCentury = twoDigitYear >= rangeEnd % 100;\n result = twoDigitYear + rangeEndCentury - (isPreviousCentury ? 100 : 0);\n }\n\n return isCommonEra ? result : 1 - result;\n}\n\nvar DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];\nvar DAYS_IN_MONTH_LEAP_YEAR = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; // User for validation\n\nfunction isLeapYearIndex(year) {\n return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;\n}\n/*\n * | | Unit | | Unit |\n * |-----|--------------------------------|-----|--------------------------------|\n * | a | AM, PM | A* | Milliseconds in day |\n * | b | AM, PM, noon, midnight | B | Flexible day period |\n * | c | Stand-alone local day of week | C* | Localized hour w/ day period |\n * | d | Day of month | D | Day of year |\n * | e | Local day of week | E | Day of week |\n * | f | | F* | Day of week in month |\n * | g* | Modified Julian day | G | Era |\n * | h | Hour [1-12] | H | Hour [0-23] |\n * | i! | ISO day of week | I! | ISO week of year |\n * | j* | Localized hour w/ day period | J* | Localized hour w/o day period |\n * | k | Hour [1-24] | K | Hour [0-11] |\n * | l* | (deprecated) | L | Stand-alone month |\n * | m | Minute | M | Month |\n * | n | | N | |\n * | o! | Ordinal number modifier | O* | Timezone (GMT) |\n * | p | | P | |\n * | q | Stand-alone quarter | Q | Quarter |\n * | r* | Related Gregorian year | R! | ISO week-numbering year |\n * | s | Second | S | Fraction of second |\n * | t! | Seconds timestamp | T! | Milliseconds timestamp |\n * | u | Extended year | U* | Cyclic year |\n * | v* | Timezone (generic non-locat.) | V* | Timezone (location) |\n * | w | Local week of year | W* | Week of month |\n * | x | Timezone (ISO-8601 w/o Z) | X | Timezone (ISO-8601) |\n * | y | Year (abs) | Y | Local week-numbering year |\n * | z* | Timezone (specific non-locat.) | Z* | Timezone (aliases) |\n *\n * Letters marked by * are not implemented but reserved by Unicode standard.\n *\n * Letters marked by ! are non-standard, but implemented by date-fns:\n * - `o` modifies the previous token to turn it into an ordinal (see `parse` docs)\n * - `i` is ISO day of week. For `i` and `ii` is returns numeric ISO week days,\n * i.e. 7 for Sunday, 1 for Monday, etc.\n * - `I` is ISO week of year, as opposed to `w` which is local week of year.\n * - `R` is ISO week-numbering year, as opposed to `Y` which is local week-numbering year.\n * `R` is supposed to be used in conjunction with `I` and `i`\n * for universal ISO week-numbering date, whereas\n * `Y` is supposed to be used in conjunction with `w` and `e`\n * for week-numbering date specific to the locale.\n */\n\n\nvar parsers = {\n // Era\n G: {\n priority: 140,\n parse: function parse(string, token, match, _options) {\n switch (token) {\n // AD, BC\n case 'G':\n case 'GG':\n case 'GGG':\n return match.era(string, {\n width: 'abbreviated'\n }) || match.era(string, {\n width: 'narrow'\n });\n // A, B\n\n case 'GGGGG':\n return match.era(string, {\n width: 'narrow'\n });\n // Anno Domini, Before Christ\n\n case 'GGGG':\n default:\n return match.era(string, {\n width: 'wide'\n }) || match.era(string, {\n width: 'abbreviated'\n }) || match.era(string, {\n width: 'narrow'\n });\n }\n },\n set: function set(date, flags, value, _options) {\n flags.era = value;\n date.setUTCFullYear(value, 0, 1);\n date.setUTCHours(0, 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['R', 'u', 't', 'T']\n },\n // Year\n y: {\n // From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_Patterns\n // | Year | y | yy | yyy | yyyy | yyyyy |\n // |----------|-------|----|-------|-------|-------|\n // | AD 1 | 1 | 01 | 001 | 0001 | 00001 |\n // | AD 12 | 12 | 12 | 012 | 0012 | 00012 |\n // | AD 123 | 123 | 23 | 123 | 0123 | 00123 |\n // | AD 1234 | 1234 | 34 | 1234 | 1234 | 01234 |\n // | AD 12345 | 12345 | 45 | 12345 | 12345 | 12345 |\n priority: 130,\n parse: function parse(string, token, match, _options) {\n var valueCallback = function valueCallback(year) {\n return {\n year: year,\n isTwoDigitYear: token === 'yy'\n };\n };\n\n switch (token) {\n case 'y':\n return parseNDigits(4, string, valueCallback);\n\n case 'yo':\n return match.ordinalNumber(string, {\n unit: 'year',\n valueCallback: valueCallback\n });\n\n default:\n return parseNDigits(token.length, string, valueCallback);\n }\n },\n validate: function validate(_date, value, _options) {\n return value.isTwoDigitYear || value.year > 0;\n },\n set: function set(date, flags, value, _options) {\n var currentYear = date.getUTCFullYear();\n\n if (value.isTwoDigitYear) {\n var normalizedTwoDigitYear = normalizeTwoDigitYear(value.year, currentYear);\n date.setUTCFullYear(normalizedTwoDigitYear, 0, 1);\n date.setUTCHours(0, 0, 0, 0);\n return date;\n }\n\n var year = !('era' in flags) || flags.era === 1 ? value.year : 1 - value.year;\n date.setUTCFullYear(year, 0, 1);\n date.setUTCHours(0, 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['Y', 'R', 'u', 'w', 'I', 'i', 'e', 'c', 't', 'T']\n },\n // Local week-numbering year\n Y: {\n priority: 130,\n parse: function parse(string, token, match, _options) {\n var valueCallback = function valueCallback(year) {\n return {\n year: year,\n isTwoDigitYear: token === 'YY'\n };\n };\n\n switch (token) {\n case 'Y':\n return parseNDigits(4, string, valueCallback);\n\n case 'Yo':\n return match.ordinalNumber(string, {\n unit: 'year',\n valueCallback: valueCallback\n });\n\n default:\n return parseNDigits(token.length, string, valueCallback);\n }\n },\n validate: function validate(_date, value, _options) {\n return value.isTwoDigitYear || value.year > 0;\n },\n set: function set(date, flags, value, options) {\n var currentYear = getUTCWeekYear(date, options);\n\n if (value.isTwoDigitYear) {\n var normalizedTwoDigitYear = normalizeTwoDigitYear(value.year, currentYear);\n date.setUTCFullYear(normalizedTwoDigitYear, 0, options.firstWeekContainsDate);\n date.setUTCHours(0, 0, 0, 0);\n return startOfUTCWeek(date, options);\n }\n\n var year = !('era' in flags) || flags.era === 1 ? value.year : 1 - value.year;\n date.setUTCFullYear(year, 0, options.firstWeekContainsDate);\n date.setUTCHours(0, 0, 0, 0);\n return startOfUTCWeek(date, options);\n },\n incompatibleTokens: ['y', 'R', 'u', 'Q', 'q', 'M', 'L', 'I', 'd', 'D', 'i', 't', 'T']\n },\n // ISO week-numbering year\n R: {\n priority: 130,\n parse: function parse(string, token, _match, _options) {\n if (token === 'R') {\n return parseNDigitsSigned(4, string);\n }\n\n return parseNDigitsSigned(token.length, string);\n },\n set: function set(_date, _flags, value, _options) {\n var firstWeekOfYear = new Date(0);\n firstWeekOfYear.setUTCFullYear(value, 0, 4);\n firstWeekOfYear.setUTCHours(0, 0, 0, 0);\n return startOfUTCISOWeek(firstWeekOfYear);\n },\n incompatibleTokens: ['G', 'y', 'Y', 'u', 'Q', 'q', 'M', 'L', 'w', 'd', 'D', 'e', 'c', 't', 'T']\n },\n // Extended year\n u: {\n priority: 130,\n parse: function parse(string, token, _match, _options) {\n if (token === 'u') {\n return parseNDigitsSigned(4, string);\n }\n\n return parseNDigitsSigned(token.length, string);\n },\n set: function set(date, _flags, value, _options) {\n date.setUTCFullYear(value, 0, 1);\n date.setUTCHours(0, 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['G', 'y', 'Y', 'R', 'w', 'I', 'i', 'e', 'c', 't', 'T']\n },\n // Quarter\n Q: {\n priority: 120,\n parse: function parse(string, token, match, _options) {\n switch (token) {\n // 1, 2, 3, 4\n case 'Q':\n case 'QQ':\n // 01, 02, 03, 04\n return parseNDigits(token.length, string);\n // 1st, 2nd, 3rd, 4th\n\n case 'Qo':\n return match.ordinalNumber(string, {\n unit: 'quarter'\n });\n // Q1, Q2, Q3, Q4\n\n case 'QQQ':\n return match.quarter(string, {\n width: 'abbreviated',\n context: 'formatting'\n }) || match.quarter(string, {\n width: 'narrow',\n context: 'formatting'\n });\n // 1, 2, 3, 4 (narrow quarter; could be not numerical)\n\n case 'QQQQQ':\n return match.quarter(string, {\n width: 'narrow',\n context: 'formatting'\n });\n // 1st quarter, 2nd quarter, ...\n\n case 'QQQQ':\n default:\n return match.quarter(string, {\n width: 'wide',\n context: 'formatting'\n }) || match.quarter(string, {\n width: 'abbreviated',\n context: 'formatting'\n }) || match.quarter(string, {\n width: 'narrow',\n context: 'formatting'\n });\n }\n },\n validate: function validate(_date, value, _options) {\n return value >= 1 && value <= 4;\n },\n set: function set(date, _flags, value, _options) {\n date.setUTCMonth((value - 1) * 3, 1);\n date.setUTCHours(0, 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['Y', 'R', 'q', 'M', 'L', 'w', 'I', 'd', 'D', 'i', 'e', 'c', 't', 'T']\n },\n // Stand-alone quarter\n q: {\n priority: 120,\n parse: function parse(string, token, match, _options) {\n switch (token) {\n // 1, 2, 3, 4\n case 'q':\n case 'qq':\n // 01, 02, 03, 04\n return parseNDigits(token.length, string);\n // 1st, 2nd, 3rd, 4th\n\n case 'qo':\n return match.ordinalNumber(string, {\n unit: 'quarter'\n });\n // Q1, Q2, Q3, Q4\n\n case 'qqq':\n return match.quarter(string, {\n width: 'abbreviated',\n context: 'standalone'\n }) || match.quarter(string, {\n width: 'narrow',\n context: 'standalone'\n });\n // 1, 2, 3, 4 (narrow quarter; could be not numerical)\n\n case 'qqqqq':\n return match.quarter(string, {\n width: 'narrow',\n context: 'standalone'\n });\n // 1st quarter, 2nd quarter, ...\n\n case 'qqqq':\n default:\n return match.quarter(string, {\n width: 'wide',\n context: 'standalone'\n }) || match.quarter(string, {\n width: 'abbreviated',\n context: 'standalone'\n }) || match.quarter(string, {\n width: 'narrow',\n context: 'standalone'\n });\n }\n },\n validate: function validate(_date, value, _options) {\n return value >= 1 && value <= 4;\n },\n set: function set(date, _flags, value, _options) {\n date.setUTCMonth((value - 1) * 3, 1);\n date.setUTCHours(0, 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['Y', 'R', 'Q', 'M', 'L', 'w', 'I', 'd', 'D', 'i', 'e', 'c', 't', 'T']\n },\n // Month\n M: {\n priority: 110,\n parse: function parse(string, token, match, _options) {\n var valueCallback = function valueCallback(value) {\n return value - 1;\n };\n\n switch (token) {\n // 1, 2, ..., 12\n case 'M':\n return parseNumericPattern(numericPatterns.month, string, valueCallback);\n // 01, 02, ..., 12\n\n case 'MM':\n return parseNDigits(2, string, valueCallback);\n // 1st, 2nd, ..., 12th\n\n case 'Mo':\n return match.ordinalNumber(string, {\n unit: 'month',\n valueCallback: valueCallback\n });\n // Jan, Feb, ..., Dec\n\n case 'MMM':\n return match.month(string, {\n width: 'abbreviated',\n context: 'formatting'\n }) || match.month(string, {\n width: 'narrow',\n context: 'formatting'\n });\n // J, F, ..., D\n\n case 'MMMMM':\n return match.month(string, {\n width: 'narrow',\n context: 'formatting'\n });\n // January, February, ..., December\n\n case 'MMMM':\n default:\n return match.month(string, {\n width: 'wide',\n context: 'formatting'\n }) || match.month(string, {\n width: 'abbreviated',\n context: 'formatting'\n }) || match.month(string, {\n width: 'narrow',\n context: 'formatting'\n });\n }\n },\n validate: function validate(_date, value, _options) {\n return value >= 0 && value <= 11;\n },\n set: function set(date, _flags, value, _options) {\n date.setUTCMonth(value, 1);\n date.setUTCHours(0, 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['Y', 'R', 'q', 'Q', 'L', 'w', 'I', 'D', 'i', 'e', 'c', 't', 'T']\n },\n // Stand-alone month\n L: {\n priority: 110,\n parse: function parse(string, token, match, _options) {\n var valueCallback = function valueCallback(value) {\n return value - 1;\n };\n\n switch (token) {\n // 1, 2, ..., 12\n case 'L':\n return parseNumericPattern(numericPatterns.month, string, valueCallback);\n // 01, 02, ..., 12\n\n case 'LL':\n return parseNDigits(2, string, valueCallback);\n // 1st, 2nd, ..., 12th\n\n case 'Lo':\n return match.ordinalNumber(string, {\n unit: 'month',\n valueCallback: valueCallback\n });\n // Jan, Feb, ..., Dec\n\n case 'LLL':\n return match.month(string, {\n width: 'abbreviated',\n context: 'standalone'\n }) || match.month(string, {\n width: 'narrow',\n context: 'standalone'\n });\n // J, F, ..., D\n\n case 'LLLLL':\n return match.month(string, {\n width: 'narrow',\n context: 'standalone'\n });\n // January, February, ..., December\n\n case 'LLLL':\n default:\n return match.month(string, {\n width: 'wide',\n context: 'standalone'\n }) || match.month(string, {\n width: 'abbreviated',\n context: 'standalone'\n }) || match.month(string, {\n width: 'narrow',\n context: 'standalone'\n });\n }\n },\n validate: function validate(_date, value, _options) {\n return value >= 0 && value <= 11;\n },\n set: function set(date, _flags, value, _options) {\n date.setUTCMonth(value, 1);\n date.setUTCHours(0, 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['Y', 'R', 'q', 'Q', 'M', 'w', 'I', 'D', 'i', 'e', 'c', 't', 'T']\n },\n // Local week of year\n w: {\n priority: 100,\n parse: function parse(string, token, match, _options) {\n switch (token) {\n case 'w':\n return parseNumericPattern(numericPatterns.week, string);\n\n case 'wo':\n return match.ordinalNumber(string, {\n unit: 'week'\n });\n\n default:\n return parseNDigits(token.length, string);\n }\n },\n validate: function validate(_date, value, _options) {\n return value >= 1 && value <= 53;\n },\n set: function set(date, _flags, value, options) {\n return startOfUTCWeek(setUTCWeek(date, value, options), options);\n },\n incompatibleTokens: ['y', 'R', 'u', 'q', 'Q', 'M', 'L', 'I', 'd', 'D', 'i', 't', 'T']\n },\n // ISO week of year\n I: {\n priority: 100,\n parse: function parse(string, token, match, _options) {\n switch (token) {\n case 'I':\n return parseNumericPattern(numericPatterns.week, string);\n\n case 'Io':\n return match.ordinalNumber(string, {\n unit: 'week'\n });\n\n default:\n return parseNDigits(token.length, string);\n }\n },\n validate: function validate(_date, value, _options) {\n return value >= 1 && value <= 53;\n },\n set: function set(date, _flags, value, options) {\n return startOfUTCISOWeek(setUTCISOWeek(date, value, options), options);\n },\n incompatibleTokens: ['y', 'Y', 'u', 'q', 'Q', 'M', 'L', 'w', 'd', 'D', 'e', 'c', 't', 'T']\n },\n // Day of the month\n d: {\n priority: 90,\n subPriority: 1,\n parse: function parse(string, token, match, _options) {\n switch (token) {\n case 'd':\n return parseNumericPattern(numericPatterns.date, string);\n\n case 'do':\n return match.ordinalNumber(string, {\n unit: 'date'\n });\n\n default:\n return parseNDigits(token.length, string);\n }\n },\n validate: function validate(date, value, _options) {\n var year = date.getUTCFullYear();\n var isLeapYear = isLeapYearIndex(year);\n var month = date.getUTCMonth();\n\n if (isLeapYear) {\n return value >= 1 && value <= DAYS_IN_MONTH_LEAP_YEAR[month];\n } else {\n return value >= 1 && value <= DAYS_IN_MONTH[month];\n }\n },\n set: function set(date, _flags, value, _options) {\n date.setUTCDate(value);\n date.setUTCHours(0, 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['Y', 'R', 'q', 'Q', 'w', 'I', 'D', 'i', 'e', 'c', 't', 'T']\n },\n // Day of year\n D: {\n priority: 90,\n subPriority: 1,\n parse: function parse(string, token, match, _options) {\n switch (token) {\n case 'D':\n case 'DD':\n return parseNumericPattern(numericPatterns.dayOfYear, string);\n\n case 'Do':\n return match.ordinalNumber(string, {\n unit: 'date'\n });\n\n default:\n return parseNDigits(token.length, string);\n }\n },\n validate: function validate(date, value, _options) {\n var year = date.getUTCFullYear();\n var isLeapYear = isLeapYearIndex(year);\n\n if (isLeapYear) {\n return value >= 1 && value <= 366;\n } else {\n return value >= 1 && value <= 365;\n }\n },\n set: function set(date, _flags, value, _options) {\n date.setUTCMonth(0, value);\n date.setUTCHours(0, 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['Y', 'R', 'q', 'Q', 'M', 'L', 'w', 'I', 'd', 'E', 'i', 'e', 'c', 't', 'T']\n },\n // Day of week\n E: {\n priority: 90,\n parse: function parse(string, token, match, _options) {\n switch (token) {\n // Tue\n case 'E':\n case 'EE':\n case 'EEE':\n return match.day(string, {\n width: 'abbreviated',\n context: 'formatting'\n }) || match.day(string, {\n width: 'short',\n context: 'formatting'\n }) || match.day(string, {\n width: 'narrow',\n context: 'formatting'\n });\n // T\n\n case 'EEEEE':\n return match.day(string, {\n width: 'narrow',\n context: 'formatting'\n });\n // Tu\n\n case 'EEEEEE':\n return match.day(string, {\n width: 'short',\n context: 'formatting'\n }) || match.day(string, {\n width: 'narrow',\n context: 'formatting'\n });\n // Tuesday\n\n case 'EEEE':\n default:\n return match.day(string, {\n width: 'wide',\n context: 'formatting'\n }) || match.day(string, {\n width: 'abbreviated',\n context: 'formatting'\n }) || match.day(string, {\n width: 'short',\n context: 'formatting'\n }) || match.day(string, {\n width: 'narrow',\n context: 'formatting'\n });\n }\n },\n validate: function validate(_date, value, _options) {\n return value >= 0 && value <= 6;\n },\n set: function set(date, _flags, value, options) {\n date = setUTCDay(date, value, options);\n date.setUTCHours(0, 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['D', 'i', 'e', 'c', 't', 'T']\n },\n // Local day of week\n e: {\n priority: 90,\n parse: function parse(string, token, match, options) {\n var valueCallback = function valueCallback(value) {\n var wholeWeekDays = Math.floor((value - 1) / 7) * 7;\n return (value + options.weekStartsOn + 6) % 7 + wholeWeekDays;\n };\n\n switch (token) {\n // 3\n case 'e':\n case 'ee':\n // 03\n return parseNDigits(token.length, string, valueCallback);\n // 3rd\n\n case 'eo':\n return match.ordinalNumber(string, {\n unit: 'day',\n valueCallback: valueCallback\n });\n // Tue\n\n case 'eee':\n return match.day(string, {\n width: 'abbreviated',\n context: 'formatting'\n }) || match.day(string, {\n width: 'short',\n context: 'formatting'\n }) || match.day(string, {\n width: 'narrow',\n context: 'formatting'\n });\n // T\n\n case 'eeeee':\n return match.day(string, {\n width: 'narrow',\n context: 'formatting'\n });\n // Tu\n\n case 'eeeeee':\n return match.day(string, {\n width: 'short',\n context: 'formatting'\n }) || match.day(string, {\n width: 'narrow',\n context: 'formatting'\n });\n // Tuesday\n\n case 'eeee':\n default:\n return match.day(string, {\n width: 'wide',\n context: 'formatting'\n }) || match.day(string, {\n width: 'abbreviated',\n context: 'formatting'\n }) || match.day(string, {\n width: 'short',\n context: 'formatting'\n }) || match.day(string, {\n width: 'narrow',\n context: 'formatting'\n });\n }\n },\n validate: function validate(_date, value, _options) {\n return value >= 0 && value <= 6;\n },\n set: function set(date, _flags, value, options) {\n date = setUTCDay(date, value, options);\n date.setUTCHours(0, 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['y', 'R', 'u', 'q', 'Q', 'M', 'L', 'I', 'd', 'D', 'E', 'i', 'c', 't', 'T']\n },\n // Stand-alone local day of week\n c: {\n priority: 90,\n parse: function parse(string, token, match, options) {\n var valueCallback = function valueCallback(value) {\n var wholeWeekDays = Math.floor((value - 1) / 7) * 7;\n return (value + options.weekStartsOn + 6) % 7 + wholeWeekDays;\n };\n\n switch (token) {\n // 3\n case 'c':\n case 'cc':\n // 03\n return parseNDigits(token.length, string, valueCallback);\n // 3rd\n\n case 'co':\n return match.ordinalNumber(string, {\n unit: 'day',\n valueCallback: valueCallback\n });\n // Tue\n\n case 'ccc':\n return match.day(string, {\n width: 'abbreviated',\n context: 'standalone'\n }) || match.day(string, {\n width: 'short',\n context: 'standalone'\n }) || match.day(string, {\n width: 'narrow',\n context: 'standalone'\n });\n // T\n\n case 'ccccc':\n return match.day(string, {\n width: 'narrow',\n context: 'standalone'\n });\n // Tu\n\n case 'cccccc':\n return match.day(string, {\n width: 'short',\n context: 'standalone'\n }) || match.day(string, {\n width: 'narrow',\n context: 'standalone'\n });\n // Tuesday\n\n case 'cccc':\n default:\n return match.day(string, {\n width: 'wide',\n context: 'standalone'\n }) || match.day(string, {\n width: 'abbreviated',\n context: 'standalone'\n }) || match.day(string, {\n width: 'short',\n context: 'standalone'\n }) || match.day(string, {\n width: 'narrow',\n context: 'standalone'\n });\n }\n },\n validate: function validate(_date, value, _options) {\n return value >= 0 && value <= 6;\n },\n set: function set(date, _flags, value, options) {\n date = setUTCDay(date, value, options);\n date.setUTCHours(0, 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['y', 'R', 'u', 'q', 'Q', 'M', 'L', 'I', 'd', 'D', 'E', 'i', 'e', 't', 'T']\n },\n // ISO day of week\n i: {\n priority: 90,\n parse: function parse(string, token, match, _options) {\n var valueCallback = function valueCallback(value) {\n if (value === 0) {\n return 7;\n }\n\n return value;\n };\n\n switch (token) {\n // 2\n case 'i':\n case 'ii':\n // 02\n return parseNDigits(token.length, string);\n // 2nd\n\n case 'io':\n return match.ordinalNumber(string, {\n unit: 'day'\n });\n // Tue\n\n case 'iii':\n return match.day(string, {\n width: 'abbreviated',\n context: 'formatting',\n valueCallback: valueCallback\n }) || match.day(string, {\n width: 'short',\n context: 'formatting',\n valueCallback: valueCallback\n }) || match.day(string, {\n width: 'narrow',\n context: 'formatting',\n valueCallback: valueCallback\n });\n // T\n\n case 'iiiii':\n return match.day(string, {\n width: 'narrow',\n context: 'formatting',\n valueCallback: valueCallback\n });\n // Tu\n\n case 'iiiiii':\n return match.day(string, {\n width: 'short',\n context: 'formatting',\n valueCallback: valueCallback\n }) || match.day(string, {\n width: 'narrow',\n context: 'formatting',\n valueCallback: valueCallback\n });\n // Tuesday\n\n case 'iiii':\n default:\n return match.day(string, {\n width: 'wide',\n context: 'formatting',\n valueCallback: valueCallback\n }) || match.day(string, {\n width: 'abbreviated',\n context: 'formatting',\n valueCallback: valueCallback\n }) || match.day(string, {\n width: 'short',\n context: 'formatting',\n valueCallback: valueCallback\n }) || match.day(string, {\n width: 'narrow',\n context: 'formatting',\n valueCallback: valueCallback\n });\n }\n },\n validate: function validate(_date, value, _options) {\n return value >= 1 && value <= 7;\n },\n set: function set(date, _flags, value, options) {\n date = setUTCISODay(date, value, options);\n date.setUTCHours(0, 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['y', 'Y', 'u', 'q', 'Q', 'M', 'L', 'w', 'd', 'D', 'E', 'e', 'c', 't', 'T']\n },\n // AM or PM\n a: {\n priority: 80,\n parse: function parse(string, token, match, _options) {\n switch (token) {\n case 'a':\n case 'aa':\n case 'aaa':\n return match.dayPeriod(string, {\n width: 'abbreviated',\n context: 'formatting'\n }) || match.dayPeriod(string, {\n width: 'narrow',\n context: 'formatting'\n });\n\n case 'aaaaa':\n return match.dayPeriod(string, {\n width: 'narrow',\n context: 'formatting'\n });\n\n case 'aaaa':\n default:\n return match.dayPeriod(string, {\n width: 'wide',\n context: 'formatting'\n }) || match.dayPeriod(string, {\n width: 'abbreviated',\n context: 'formatting'\n }) || match.dayPeriod(string, {\n width: 'narrow',\n context: 'formatting'\n });\n }\n },\n set: function set(date, _flags, value, _options) {\n date.setUTCHours(dayPeriodEnumToHours(value), 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['b', 'B', 'H', 'K', 'k', 't', 'T']\n },\n // AM, PM, midnight\n b: {\n priority: 80,\n parse: function parse(string, token, match, _options) {\n switch (token) {\n case 'b':\n case 'bb':\n case 'bbb':\n return match.dayPeriod(string, {\n width: 'abbreviated',\n context: 'formatting'\n }) || match.dayPeriod(string, {\n width: 'narrow',\n context: 'formatting'\n });\n\n case 'bbbbb':\n return match.dayPeriod(string, {\n width: 'narrow',\n context: 'formatting'\n });\n\n case 'bbbb':\n default:\n return match.dayPeriod(string, {\n width: 'wide',\n context: 'formatting'\n }) || match.dayPeriod(string, {\n width: 'abbreviated',\n context: 'formatting'\n }) || match.dayPeriod(string, {\n width: 'narrow',\n context: 'formatting'\n });\n }\n },\n set: function set(date, _flags, value, _options) {\n date.setUTCHours(dayPeriodEnumToHours(value), 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['a', 'B', 'H', 'K', 'k', 't', 'T']\n },\n // in the morning, in the afternoon, in the evening, at night\n B: {\n priority: 80,\n parse: function parse(string, token, match, _options) {\n switch (token) {\n case 'B':\n case 'BB':\n case 'BBB':\n return match.dayPeriod(string, {\n width: 'abbreviated',\n context: 'formatting'\n }) || match.dayPeriod(string, {\n width: 'narrow',\n context: 'formatting'\n });\n\n case 'BBBBB':\n return match.dayPeriod(string, {\n width: 'narrow',\n context: 'formatting'\n });\n\n case 'BBBB':\n default:\n return match.dayPeriod(string, {\n width: 'wide',\n context: 'formatting'\n }) || match.dayPeriod(string, {\n width: 'abbreviated',\n context: 'formatting'\n }) || match.dayPeriod(string, {\n width: 'narrow',\n context: 'formatting'\n });\n }\n },\n set: function set(date, _flags, value, _options) {\n date.setUTCHours(dayPeriodEnumToHours(value), 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['a', 'b', 't', 'T']\n },\n // Hour [1-12]\n h: {\n priority: 70,\n parse: function parse(string, token, match, _options) {\n switch (token) {\n case 'h':\n return parseNumericPattern(numericPatterns.hour12h, string);\n\n case 'ho':\n return match.ordinalNumber(string, {\n unit: 'hour'\n });\n\n default:\n return parseNDigits(token.length, string);\n }\n },\n validate: function validate(_date, value, _options) {\n return value >= 1 && value <= 12;\n },\n set: function set(date, _flags, value, _options) {\n var isPM = date.getUTCHours() >= 12;\n\n if (isPM && value < 12) {\n date.setUTCHours(value + 12, 0, 0, 0);\n } else if (!isPM && value === 12) {\n date.setUTCHours(0, 0, 0, 0);\n } else {\n date.setUTCHours(value, 0, 0, 0);\n }\n\n return date;\n },\n incompatibleTokens: ['H', 'K', 'k', 't', 'T']\n },\n // Hour [0-23]\n H: {\n priority: 70,\n parse: function parse(string, token, match, _options) {\n switch (token) {\n case 'H':\n return parseNumericPattern(numericPatterns.hour23h, string);\n\n case 'Ho':\n return match.ordinalNumber(string, {\n unit: 'hour'\n });\n\n default:\n return parseNDigits(token.length, string);\n }\n },\n validate: function validate(_date, value, _options) {\n return value >= 0 && value <= 23;\n },\n set: function set(date, _flags, value, _options) {\n date.setUTCHours(value, 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['a', 'b', 'h', 'K', 'k', 't', 'T']\n },\n // Hour [0-11]\n K: {\n priority: 70,\n parse: function parse(string, token, match, _options) {\n switch (token) {\n case 'K':\n return parseNumericPattern(numericPatterns.hour11h, string);\n\n case 'Ko':\n return match.ordinalNumber(string, {\n unit: 'hour'\n });\n\n default:\n return parseNDigits(token.length, string);\n }\n },\n validate: function validate(_date, value, _options) {\n return value >= 0 && value <= 11;\n },\n set: function set(date, _flags, value, _options) {\n var isPM = date.getUTCHours() >= 12;\n\n if (isPM && value < 12) {\n date.setUTCHours(value + 12, 0, 0, 0);\n } else {\n date.setUTCHours(value, 0, 0, 0);\n }\n\n return date;\n },\n incompatibleTokens: ['a', 'b', 'h', 'H', 'k', 't', 'T']\n },\n // Hour [1-24]\n k: {\n priority: 70,\n parse: function parse(string, token, match, _options) {\n switch (token) {\n case 'k':\n return parseNumericPattern(numericPatterns.hour24h, string);\n\n case 'ko':\n return match.ordinalNumber(string, {\n unit: 'hour'\n });\n\n default:\n return parseNDigits(token.length, string);\n }\n },\n validate: function validate(_date, value, _options) {\n return value >= 1 && value <= 24;\n },\n set: function set(date, _flags, value, _options) {\n var hours = value <= 24 ? value % 24 : value;\n date.setUTCHours(hours, 0, 0, 0);\n return date;\n },\n incompatibleTokens: ['a', 'b', 'h', 'H', 'K', 't', 'T']\n },\n // Minute\n m: {\n priority: 60,\n parse: function parse(string, token, match, _options) {\n switch (token) {\n case 'm':\n return parseNumericPattern(numericPatterns.minute, string);\n\n case 'mo':\n return match.ordinalNumber(string, {\n unit: 'minute'\n });\n\n default:\n return parseNDigits(token.length, string);\n }\n },\n validate: function validate(_date, value, _options) {\n return value >= 0 && value <= 59;\n },\n set: function set(date, _flags, value, _options) {\n date.setUTCMinutes(value, 0, 0);\n return date;\n },\n incompatibleTokens: ['t', 'T']\n },\n // Second\n s: {\n priority: 50,\n parse: function parse(string, token, match, _options) {\n switch (token) {\n case 's':\n return parseNumericPattern(numericPatterns.second, string);\n\n case 'so':\n return match.ordinalNumber(string, {\n unit: 'second'\n });\n\n default:\n return parseNDigits(token.length, string);\n }\n },\n validate: function validate(_date, value, _options) {\n return value >= 0 && value <= 59;\n },\n set: function set(date, _flags, value, _options) {\n date.setUTCSeconds(value, 0);\n return date;\n },\n incompatibleTokens: ['t', 'T']\n },\n // Fraction of second\n S: {\n priority: 30,\n parse: function parse(string, token, _match, _options) {\n var valueCallback = function valueCallback(value) {\n return Math.floor(value * Math.pow(10, -token.length + 3));\n };\n\n return parseNDigits(token.length, string, valueCallback);\n },\n set: function set(date, _flags, value, _options) {\n date.setUTCMilliseconds(value);\n return date;\n },\n incompatibleTokens: ['t', 'T']\n },\n // Timezone (ISO-8601. +00:00 is `'Z'`)\n X: {\n priority: 10,\n parse: function parse(string, token, _match, _options) {\n switch (token) {\n case 'X':\n return parseTimezonePattern(timezonePatterns.basicOptionalMinutes, string);\n\n case 'XX':\n return parseTimezonePattern(timezonePatterns.basic, string);\n\n case 'XXXX':\n return parseTimezonePattern(timezonePatterns.basicOptionalSeconds, string);\n\n case 'XXXXX':\n return parseTimezonePattern(timezonePatterns.extendedOptionalSeconds, string);\n\n case 'XXX':\n default:\n return parseTimezonePattern(timezonePatterns.extended, string);\n }\n },\n set: function set(date, flags, value, _options) {\n if (flags.timestampIsSet) {\n return date;\n }\n\n return new Date(date.getTime() - value);\n },\n incompatibleTokens: ['t', 'T', 'x']\n },\n // Timezone (ISO-8601)\n x: {\n priority: 10,\n parse: function parse(string, token, _match, _options) {\n switch (token) {\n case 'x':\n return parseTimezonePattern(timezonePatterns.basicOptionalMinutes, string);\n\n case 'xx':\n return parseTimezonePattern(timezonePatterns.basic, string);\n\n case 'xxxx':\n return parseTimezonePattern(timezonePatterns.basicOptionalSeconds, string);\n\n case 'xxxxx':\n return parseTimezonePattern(timezonePatterns.extendedOptionalSeconds, string);\n\n case 'xxx':\n default:\n return parseTimezonePattern(timezonePatterns.extended, string);\n }\n },\n set: function set(date, flags, value, _options) {\n if (flags.timestampIsSet) {\n return date;\n }\n\n return new Date(date.getTime() - value);\n },\n incompatibleTokens: ['t', 'T', 'X']\n },\n // Seconds timestamp\n t: {\n priority: 40,\n parse: function parse(string, _token, _match, _options) {\n return parseAnyDigitsSigned(string);\n },\n set: function set(_date, _flags, value, _options) {\n return [new Date(value * 1000), {\n timestampIsSet: true\n }];\n },\n incompatibleTokens: '*'\n },\n // Milliseconds timestamp\n T: {\n priority: 20,\n parse: function parse(string, _token, _match, _options) {\n return parseAnyDigitsSigned(string);\n },\n set: function set(_date, _flags, value, _options) {\n return [new Date(value), {\n timestampIsSet: true\n }];\n },\n incompatibleTokens: '*'\n }\n};\nexport default parsers;","import toInteger from \"../toInteger/index.js\";\nimport toDate from \"../../toDate/index.js\";\nimport getUTCWeek from \"../getUTCWeek/index.js\";\nimport requiredArgs from \"../requiredArgs/index.js\"; // This function will be a part of public API when UTC function will be implemented.\n// See issue: https://github.com/date-fns/date-fns/issues/376\n\nexport default function setUTCWeek(dirtyDate, dirtyWeek, options) {\n requiredArgs(2, arguments);\n var date = toDate(dirtyDate);\n var week = toInteger(dirtyWeek);\n var diff = getUTCWeek(date, options) - week;\n date.setUTCDate(date.getUTCDate() - diff * 7);\n return date;\n}","import toInteger from \"../toInteger/index.js\";\nimport toDate from \"../../toDate/index.js\";\nimport getUTCISOWeek from \"../getUTCISOWeek/index.js\";\nimport requiredArgs from \"../requiredArgs/index.js\"; // This function will be a part of public API when UTC function will be implemented.\n// See issue: https://github.com/date-fns/date-fns/issues/376\n\nexport default function setUTCISOWeek(dirtyDate, dirtyISOWeek) {\n requiredArgs(2, arguments);\n var date = toDate(dirtyDate);\n var isoWeek = toInteger(dirtyISOWeek);\n var diff = getUTCISOWeek(date) - isoWeek;\n date.setUTCDate(date.getUTCDate() - diff * 7);\n return date;\n}","import toInteger from \"../toInteger/index.js\";\nimport toDate from \"../../toDate/index.js\";\nimport requiredArgs from \"../requiredArgs/index.js\"; // This function will be a part of public API when UTC function will be implemented.\n// See issue: https://github.com/date-fns/date-fns/issues/376\n\nexport default function setUTCISODay(dirtyDate, dirtyDay) {\n requiredArgs(2, arguments);\n var day = toInteger(dirtyDay);\n\n if (day % 7 === 0) {\n day = day - 7;\n }\n\n var weekStartsOn = 1;\n var date = toDate(dirtyDate);\n var currentDay = date.getUTCDay();\n var remainder = day % 7;\n var dayIndex = (remainder + 7) % 7;\n var diff = (dayIndex < weekStartsOn ? 7 : 0) + day - currentDay;\n date.setUTCDate(date.getUTCDate() + diff);\n return date;\n}","import defaultLocale from \"../locale/en-US/index.js\";\nimport subMilliseconds from \"../subMilliseconds/index.js\";\nimport toDate from \"../toDate/index.js\";\nimport assign from \"../_lib/assign/index.js\";\nimport longFormatters from \"../_lib/format/longFormatters/index.js\";\nimport getTimezoneOffsetInMilliseconds from \"../_lib/getTimezoneOffsetInMilliseconds/index.js\";\nimport { isProtectedDayOfYearToken, isProtectedWeekYearToken, throwProtectedError } from \"../_lib/protectedTokens/index.js\";\nimport toInteger from \"../_lib/toInteger/index.js\";\nimport parsers from \"./_lib/parsers/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\nvar TIMEZONE_UNIT_PRIORITY = 10; // This RegExp consists of three parts separated by `|`:\n// - [yYQqMLwIdDecihHKkms]o matches any available ordinal number token\n// (one of the certain letters followed by `o`)\n// - (\\w)\\1* matches any sequences of the same letter\n// - '' matches two quote characters in a row\n// - '(''|[^'])+('|$) matches anything surrounded by two quote characters ('),\n// except a single quote symbol, which ends the sequence.\n// Two quote characters do not end the sequence.\n// If there is no matching single quote\n// then the sequence will continue until the end of the string.\n// - . matches any single character unmatched by previous parts of the RegExps\n\nvar formattingTokensRegExp = /[yYQqMLwIdDecihHKkms]o|(\\w)\\1*|''|'(''|[^'])+('|$)|./g; // This RegExp catches symbols escaped by quotes, and also\n// sequences of symbols P, p, and the combinations like `PPPPPPPppppp`\n\nvar longFormattingTokensRegExp = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;\nvar escapedStringRegExp = /^'([^]*?)'?$/;\nvar doubleQuoteRegExp = /''/g;\nvar notWhitespaceRegExp = /\\S/;\nvar unescapedLatinCharacterRegExp = /[a-zA-Z]/;\n/**\n * @name parse\n * @category Common Helpers\n * @summary Parse the date.\n *\n * @description\n * Return the date parsed from string using the given format string.\n *\n * > ⚠️ Please note that the `format` tokens differ from Moment.js and other libraries.\n * > See: https://git.io/fxCyr\n *\n * The characters in the format string wrapped between two single quotes characters (') are escaped.\n * Two single quotes in a row, whether inside or outside a quoted sequence, represent a 'real' single quote.\n *\n * Format of the format string is based on Unicode Technical Standard #35:\n * https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table\n * with a few additions (see note 5 below the table).\n *\n * Not all tokens are compatible. Combinations that don't make sense or could lead to bugs are prohibited\n * and will throw `RangeError`. For example usage of 24-hour format token with AM/PM token will throw an exception:\n *\n * ```javascript\n * parse('23 AM', 'HH a', new Date())\n * //=> RangeError: The format string mustn't contain `HH` and `a` at the same time\n * ```\n *\n * See the compatibility table: https://docs.google.com/spreadsheets/d/e/2PACX-1vQOPU3xUhplll6dyoMmVUXHKl_8CRDs6_ueLmex3SoqwhuolkuN3O05l4rqx5h1dKX8eb46Ul-CCSrq/pubhtml?gid=0&single=true\n *\n * Accepted format string patterns:\n * | Unit |Prior| Pattern | Result examples | Notes |\n * |---------------------------------|-----|---------|-----------------------------------|-------|\n * | Era | 140 | G..GGG | AD, BC | |\n * | | | GGGG | Anno Domini, Before Christ | 2 |\n * | | | GGGGG | A, B | |\n * | Calendar year | 130 | y | 44, 1, 1900, 2017, 9999 | 4 |\n * | | | yo | 44th, 1st, 1900th, 9999999th | 4,5 |\n * | | | yy | 44, 01, 00, 17 | 4 |\n * | | | yyy | 044, 001, 123, 999 | 4 |\n * | | | yyyy | 0044, 0001, 1900, 2017 | 4 |\n * | | | yyyyy | ... | 2,4 |\n * | Local week-numbering year | 130 | Y | 44, 1, 1900, 2017, 9000 | 4 |\n * | | | Yo | 44th, 1st, 1900th, 9999999th | 4,5 |\n * | | | YY | 44, 01, 00, 17 | 4,6 |\n * | | | YYY | 044, 001, 123, 999 | 4 |\n * | | | YYYY | 0044, 0001, 1900, 2017 | 4,6 |\n * | | | YYYYY | ... | 2,4 |\n * | ISO week-numbering year | 130 | R | -43, 1, 1900, 2017, 9999, -9999 | 4,5 |\n * | | | RR | -43, 01, 00, 17 | 4,5 |\n * | | | RRR | -043, 001, 123, 999, -999 | 4,5 |\n * | | | RRRR | -0043, 0001, 2017, 9999, -9999 | 4,5 |\n * | | | RRRRR | ... | 2,4,5 |\n * | Extended year | 130 | u | -43, 1, 1900, 2017, 9999, -999 | 4 |\n * | | | uu | -43, 01, 99, -99 | 4 |\n * | | | uuu | -043, 001, 123, 999, -999 | 4 |\n * | | | uuuu | -0043, 0001, 2017, 9999, -9999 | 4 |\n * | | | uuuuu | ... | 2,4 |\n * | Quarter (formatting) | 120 | Q | 1, 2, 3, 4 | |\n * | | | Qo | 1st, 2nd, 3rd, 4th | 5 |\n * | | | QQ | 01, 02, 03, 04 | |\n * | | | QQQ | Q1, Q2, Q3, Q4 | |\n * | | | QQQQ | 1st quarter, 2nd quarter, ... | 2 |\n * | | | QQQQQ | 1, 2, 3, 4 | 4 |\n * | Quarter (stand-alone) | 120 | q | 1, 2, 3, 4 | |\n * | | | qo | 1st, 2nd, 3rd, 4th | 5 |\n * | | | qq | 01, 02, 03, 04 | |\n * | | | qqq | Q1, Q2, Q3, Q4 | |\n * | | | qqqq | 1st quarter, 2nd quarter, ... | 2 |\n * | | | qqqqq | 1, 2, 3, 4 | 3 |\n * | Month (formatting) | 110 | M | 1, 2, ..., 12 | |\n * | | | Mo | 1st, 2nd, ..., 12th | 5 |\n * | | | MM | 01, 02, ..., 12 | |\n * | | | MMM | Jan, Feb, ..., Dec | |\n * | | | MMMM | January, February, ..., December | 2 |\n * | | | MMMMM | J, F, ..., D | |\n * | Month (stand-alone) | 110 | L | 1, 2, ..., 12 | |\n * | | | Lo | 1st, 2nd, ..., 12th | 5 |\n * | | | LL | 01, 02, ..., 12 | |\n * | | | LLL | Jan, Feb, ..., Dec | |\n * | | | LLLL | January, February, ..., December | 2 |\n * | | | LLLLL | J, F, ..., D | |\n * | Local week of year | 100 | w | 1, 2, ..., 53 | |\n * | | | wo | 1st, 2nd, ..., 53th | 5 |\n * | | | ww | 01, 02, ..., 53 | |\n * | ISO week of year | 100 | I | 1, 2, ..., 53 | 5 |\n * | | | Io | 1st, 2nd, ..., 53th | 5 |\n * | | | II | 01, 02, ..., 53 | 5 |\n * | Day of month | 90 | d | 1, 2, ..., 31 | |\n * | | | do | 1st, 2nd, ..., 31st | 5 |\n * | | | dd | 01, 02, ..., 31 | |\n * | Day of year | 90 | D | 1, 2, ..., 365, 366 | 7 |\n * | | | Do | 1st, 2nd, ..., 365th, 366th | 5 |\n * | | | DD | 01, 02, ..., 365, 366 | 7 |\n * | | | DDD | 001, 002, ..., 365, 366 | |\n * | | | DDDD | ... | 2 |\n * | Day of week (formatting) | 90 | E..EEE | Mon, Tue, Wed, ..., Sun | |\n * | | | EEEE | Monday, Tuesday, ..., Sunday | 2 |\n * | | | EEEEE | M, T, W, T, F, S, S | |\n * | | | EEEEEE | Mo, Tu, We, Th, Fr, Su, Sa | |\n * | ISO day of week (formatting) | 90 | i | 1, 2, 3, ..., 7 | 5 |\n * | | | io | 1st, 2nd, ..., 7th | 5 |\n * | | | ii | 01, 02, ..., 07 | 5 |\n * | | | iii | Mon, Tue, Wed, ..., Sun | 5 |\n * | | | iiii | Monday, Tuesday, ..., Sunday | 2,5 |\n * | | | iiiii | M, T, W, T, F, S, S | 5 |\n * | | | iiiiii | Mo, Tu, We, Th, Fr, Su, Sa | 5 |\n * | Local day of week (formatting) | 90 | e | 2, 3, 4, ..., 1 | |\n * | | | eo | 2nd, 3rd, ..., 1st | 5 |\n * | | | ee | 02, 03, ..., 01 | |\n * | | | eee | Mon, Tue, Wed, ..., Sun | |\n * | | | eeee | Monday, Tuesday, ..., Sunday | 2 |\n * | | | eeeee | M, T, W, T, F, S, S | |\n * | | | eeeeee | Mo, Tu, We, Th, Fr, Su, Sa | |\n * | Local day of week (stand-alone) | 90 | c | 2, 3, 4, ..., 1 | |\n * | | | co | 2nd, 3rd, ..., 1st | 5 |\n * | | | cc | 02, 03, ..., 01 | |\n * | | | ccc | Mon, Tue, Wed, ..., Sun | |\n * | | | cccc | Monday, Tuesday, ..., Sunday | 2 |\n * | | | ccccc | M, T, W, T, F, S, S | |\n * | | | cccccc | Mo, Tu, We, Th, Fr, Su, Sa | |\n * | AM, PM | 80 | a..aaa | AM, PM | |\n * | | | aaaa | a.m., p.m. | 2 |\n * | | | aaaaa | a, p | |\n * | AM, PM, noon, midnight | 80 | b..bbb | AM, PM, noon, midnight | |\n * | | | bbbb | a.m., p.m., noon, midnight | 2 |\n * | | | bbbbb | a, p, n, mi | |\n * | Flexible day period | 80 | B..BBB | at night, in the morning, ... | |\n * | | | BBBB | at night, in the morning, ... | 2 |\n * | | | BBBBB | at night, in the morning, ... | |\n * | Hour [1-12] | 70 | h | 1, 2, ..., 11, 12 | |\n * | | | ho | 1st, 2nd, ..., 11th, 12th | 5 |\n * | | | hh | 01, 02, ..., 11, 12 | |\n * | Hour [0-23] | 70 | H | 0, 1, 2, ..., 23 | |\n * | | | Ho | 0th, 1st, 2nd, ..., 23rd | 5 |\n * | | | HH | 00, 01, 02, ..., 23 | |\n * | Hour [0-11] | 70 | K | 1, 2, ..., 11, 0 | |\n * | | | Ko | 1st, 2nd, ..., 11th, 0th | 5 |\n * | | | KK | 01, 02, ..., 11, 00 | |\n * | Hour [1-24] | 70 | k | 24, 1, 2, ..., 23 | |\n * | | | ko | 24th, 1st, 2nd, ..., 23rd | 5 |\n * | | | kk | 24, 01, 02, ..., 23 | |\n * | Minute | 60 | m | 0, 1, ..., 59 | |\n * | | | mo | 0th, 1st, ..., 59th | 5 |\n * | | | mm | 00, 01, ..., 59 | |\n * | Second | 50 | s | 0, 1, ..., 59 | |\n * | | | so | 0th, 1st, ..., 59th | 5 |\n * | | | ss | 00, 01, ..., 59 | |\n * | Seconds timestamp | 40 | t | 512969520 | |\n * | | | tt | ... | 2 |\n * | Fraction of second | 30 | S | 0, 1, ..., 9 | |\n * | | | SS | 00, 01, ..., 99 | |\n * | | | SSS | 000, 0001, ..., 999 | |\n * | | | SSSS | ... | 2 |\n * | Milliseconds timestamp | 20 | T | 512969520900 | |\n * | | | TT | ... | 2 |\n * | Timezone (ISO-8601 w/ Z) | 10 | X | -08, +0530, Z | |\n * | | | XX | -0800, +0530, Z | |\n * | | | XXX | -08:00, +05:30, Z | |\n * | | | XXXX | -0800, +0530, Z, +123456 | 2 |\n * | | | XXXXX | -08:00, +05:30, Z, +12:34:56 | |\n * | Timezone (ISO-8601 w/o Z) | 10 | x | -08, +0530, +00 | |\n * | | | xx | -0800, +0530, +0000 | |\n * | | | xxx | -08:00, +05:30, +00:00 | 2 |\n * | | | xxxx | -0800, +0530, +0000, +123456 | |\n * | | | xxxxx | -08:00, +05:30, +00:00, +12:34:56 | |\n * | Long localized date | NA | P | 05/29/1453 | 5,8 |\n * | | | PP | May 29, 1453 | |\n * | | | PPP | May 29th, 1453 | |\n * | | | PPPP | Sunday, May 29th, 1453 | 2,5,8 |\n * | Long localized time | NA | p | 12:00 AM | 5,8 |\n * | | | pp | 12:00:00 AM | |\n * | Combination of date and time | NA | Pp | 05/29/1453, 12:00 AM | |\n * | | | PPpp | May 29, 1453, 12:00:00 AM | |\n * | | | PPPpp | May 29th, 1453 at ... | |\n * | | | PPPPpp | Sunday, May 29th, 1453 at ... | 2,5,8 |\n * Notes:\n * 1. \"Formatting\" units (e.g. formatting quarter) in the default en-US locale\n * are the same as \"stand-alone\" units, but are different in some languages.\n * \"Formatting\" units are declined according to the rules of the language\n * in the context of a date. \"Stand-alone\" units are always nominative singular.\n * In `format` function, they will produce different result:\n *\n * `format(new Date(2017, 10, 6), 'do LLLL', {locale: cs}) //=> '6. listopad'`\n *\n * `format(new Date(2017, 10, 6), 'do MMMM', {locale: cs}) //=> '6. listopadu'`\n *\n * `parse` will try to match both formatting and stand-alone units interchangably.\n *\n * 2. Any sequence of the identical letters is a pattern, unless it is escaped by\n * the single quote characters (see below).\n * If the sequence is longer than listed in table:\n * - for numerical units (`yyyyyyyy`) `parse` will try to match a number\n * as wide as the sequence\n * - for text units (`MMMMMMMM`) `parse` will try to match the widest variation of the unit.\n * These variations are marked with \"2\" in the last column of the table.\n *\n * 3. `QQQQQ` and `qqqqq` could be not strictly numerical in some locales.\n * These tokens represent the shortest form of the quarter.\n *\n * 4. The main difference between `y` and `u` patterns are B.C. years:\n *\n * | Year | `y` | `u` |\n * |------|-----|-----|\n * | AC 1 | 1 | 1 |\n * | BC 1 | 1 | 0 |\n * | BC 2 | 2 | -1 |\n *\n * Also `yy` will try to guess the century of two digit year by proximity with `referenceDate`:\n *\n * `parse('50', 'yy', new Date(2018, 0, 1)) //=> Sat Jan 01 2050 00:00:00`\n *\n * `parse('75', 'yy', new Date(2018, 0, 1)) //=> Wed Jan 01 1975 00:00:00`\n *\n * while `uu` will just assign the year as is:\n *\n * `parse('50', 'uu', new Date(2018, 0, 1)) //=> Sat Jan 01 0050 00:00:00`\n *\n * `parse('75', 'uu', new Date(2018, 0, 1)) //=> Tue Jan 01 0075 00:00:00`\n *\n * The same difference is true for local and ISO week-numbering years (`Y` and `R`),\n * except local week-numbering years are dependent on `options.weekStartsOn`\n * and `options.firstWeekContainsDate` (compare [setISOWeekYear]{@link https://date-fns.org/docs/setISOWeekYear}\n * and [setWeekYear]{@link https://date-fns.org/docs/setWeekYear}).\n *\n * 5. These patterns are not in the Unicode Technical Standard #35:\n * - `i`: ISO day of week\n * - `I`: ISO week of year\n * - `R`: ISO week-numbering year\n * - `o`: ordinal number modifier\n * - `P`: long localized date\n * - `p`: long localized time\n *\n * 6. `YY` and `YYYY` tokens represent week-numbering years but they are often confused with years.\n * You should enable `options.useAdditionalWeekYearTokens` to use them. See: https://git.io/fxCyr\n *\n * 7. `D` and `DD` tokens represent days of the year but they are ofthen confused with days of the month.\n * You should enable `options.useAdditionalDayOfYearTokens` to use them. See: https://git.io/fxCyr\n *\n * 8. `P+` tokens do not have a defined priority since they are merely aliases to other tokens based\n * on the given locale.\n *\n * using `en-US` locale: `P` => `MM/dd/yyyy`\n * using `en-US` locale: `p` => `hh:mm a`\n * using `pt-BR` locale: `P` => `dd/MM/yyyy`\n * using `pt-BR` locale: `p` => `HH:mm`\n *\n * Values will be assigned to the date in the descending order of its unit's priority.\n * Units of an equal priority overwrite each other in the order of appearance.\n *\n * If no values of higher priority are parsed (e.g. when parsing string 'January 1st' without a year),\n * the values will be taken from 3rd argument `referenceDate` which works as a context of parsing.\n *\n * `referenceDate` must be passed for correct work of the function.\n * If you're not sure which `referenceDate` to supply, create a new instance of Date:\n * `parse('02/11/2014', 'MM/dd/yyyy', new Date())`\n * In this case parsing will be done in the context of the current date.\n * If `referenceDate` is `Invalid Date` or a value not convertible to valid `Date`,\n * then `Invalid Date` will be returned.\n *\n * The result may vary by locale.\n *\n * If `formatString` matches with `dateString` but does not provides tokens, `referenceDate` will be returned.\n *\n * If parsing failed, `Invalid Date` will be returned.\n * Invalid Date is a Date, whose time value is NaN.\n * Time value of Date: http://es5.github.io/#x15.9.1.1\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * - Old `parse` was renamed to `toDate`.\n * Now `parse` is a new function which parses a string using a provided format.\n *\n * ```javascript\n * // Before v2.0.0\n * parse('2016-01-01')\n *\n * // v2.0.0 onward (toDate no longer accepts a string)\n * toDate(1392098430000) // Unix to timestamp\n * toDate(new Date(2014, 1, 11, 11, 30, 30)) // Cloning the date\n * parse('2016-01-01', 'yyyy-MM-dd', new Date())\n * ```\n *\n * @param {String} dateString - the string to parse\n * @param {String} formatString - the string of tokens\n * @param {Date|Number} referenceDate - defines values missing from the parsed dateString\n * @param {Object} [options] - an object with options.\n * @param {Locale} [options.locale=defaultLocale] - the locale object. See [Locale]{@link https://date-fns.org/docs/Locale}\n * @param {0|1|2|3|4|5|6} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)\n * @param {1|2|3|4|5|6|7} [options.firstWeekContainsDate=1] - the day of January, which is always in the first week of the year\n * @param {Boolean} [options.useAdditionalWeekYearTokens=false] - if true, allows usage of the week-numbering year tokens `YY` and `YYYY`;\n * see: https://git.io/fxCyr\n * @param {Boolean} [options.useAdditionalDayOfYearTokens=false] - if true, allows usage of the day of year tokens `D` and `DD`;\n * see: https://git.io/fxCyr\n * @returns {Date} the parsed date\n * @throws {TypeError} 3 arguments required\n * @throws {RangeError} `options.weekStartsOn` must be between 0 and 6\n * @throws {RangeError} `options.firstWeekContainsDate` must be between 1 and 7\n * @throws {RangeError} `options.locale` must contain `match` property\n * @throws {RangeError} use `yyyy` instead of `YYYY` for formatting years using [format provided] to the input [input provided]; see: https://git.io/fxCyr\n * @throws {RangeError} use `yy` instead of `YY` for formatting years using [format provided] to the input [input provided]; see: https://git.io/fxCyr\n * @throws {RangeError} use `d` instead of `D` for formatting days of the month using [format provided] to the input [input provided]; see: https://git.io/fxCyr\n * @throws {RangeError} use `dd` instead of `DD` for formatting days of the month using [format provided] to the input [input provided]; see: https://git.io/fxCyr\n * @throws {RangeError} format string contains an unescaped latin alphabet character\n *\n * @example\n * // Parse 11 February 2014 from middle-endian format:\n * var result = parse('02/11/2014', 'MM/dd/yyyy', new Date())\n * //=> Tue Feb 11 2014 00:00:00\n *\n * @example\n * // Parse 28th of February in Esperanto locale in the context of 2010 year:\n * import eo from 'date-fns/locale/eo'\n * var result = parse('28-a de februaro', \"do 'de' MMMM\", new Date(2010, 0, 1), {\n * locale: eo\n * })\n * //=> Sun Feb 28 2010 00:00:00\n */\n\nexport default function parse(dirtyDateString, dirtyFormatString, dirtyReferenceDate, dirtyOptions) {\n requiredArgs(3, arguments);\n var dateString = String(dirtyDateString);\n var formatString = String(dirtyFormatString);\n var options = dirtyOptions || {};\n var locale = options.locale || defaultLocale;\n\n if (!locale.match) {\n throw new RangeError('locale must contain match property');\n }\n\n var localeFirstWeekContainsDate = locale.options && locale.options.firstWeekContainsDate;\n var defaultFirstWeekContainsDate = localeFirstWeekContainsDate == null ? 1 : toInteger(localeFirstWeekContainsDate);\n var firstWeekContainsDate = options.firstWeekContainsDate == null ? defaultFirstWeekContainsDate : toInteger(options.firstWeekContainsDate); // Test if weekStartsOn is between 1 and 7 _and_ is not NaN\n\n if (!(firstWeekContainsDate >= 1 && firstWeekContainsDate <= 7)) {\n throw new RangeError('firstWeekContainsDate must be between 1 and 7 inclusively');\n }\n\n var localeWeekStartsOn = locale.options && locale.options.weekStartsOn;\n var defaultWeekStartsOn = localeWeekStartsOn == null ? 0 : toInteger(localeWeekStartsOn);\n var weekStartsOn = options.weekStartsOn == null ? defaultWeekStartsOn : toInteger(options.weekStartsOn); // Test if weekStartsOn is between 0 and 6 _and_ is not NaN\n\n if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {\n throw new RangeError('weekStartsOn must be between 0 and 6 inclusively');\n }\n\n if (formatString === '') {\n if (dateString === '') {\n return toDate(dirtyReferenceDate);\n } else {\n return new Date(NaN);\n }\n }\n\n var subFnOptions = {\n firstWeekContainsDate: firstWeekContainsDate,\n weekStartsOn: weekStartsOn,\n locale: locale // If timezone isn't specified, it will be set to the system timezone\n\n };\n var setters = [{\n priority: TIMEZONE_UNIT_PRIORITY,\n subPriority: -1,\n set: dateToSystemTimezone,\n index: 0\n }];\n var i;\n var tokens = formatString.match(longFormattingTokensRegExp).map(function (substring) {\n var firstCharacter = substring[0];\n\n if (firstCharacter === 'p' || firstCharacter === 'P') {\n var longFormatter = longFormatters[firstCharacter];\n return longFormatter(substring, locale.formatLong, subFnOptions);\n }\n\n return substring;\n }).join('').match(formattingTokensRegExp);\n var usedTokens = [];\n\n for (i = 0; i < tokens.length; i++) {\n var token = tokens[i];\n\n if (!options.useAdditionalWeekYearTokens && isProtectedWeekYearToken(token)) {\n throwProtectedError(token, formatString, dirtyDateString);\n }\n\n if (!options.useAdditionalDayOfYearTokens && isProtectedDayOfYearToken(token)) {\n throwProtectedError(token, formatString, dirtyDateString);\n }\n\n var firstCharacter = token[0];\n var parser = parsers[firstCharacter];\n\n if (parser) {\n var incompatibleTokens = parser.incompatibleTokens;\n\n if (Array.isArray(incompatibleTokens)) {\n var incompatibleToken = void 0;\n\n for (var _i = 0; _i < usedTokens.length; _i++) {\n var usedToken = usedTokens[_i].token;\n\n if (incompatibleTokens.indexOf(usedToken) !== -1 || usedToken === firstCharacter) {\n incompatibleToken = usedTokens[_i];\n break;\n }\n }\n\n if (incompatibleToken) {\n throw new RangeError(\"The format string mustn't contain `\".concat(incompatibleToken.fullToken, \"` and `\").concat(token, \"` at the same time\"));\n }\n } else if (parser.incompatibleTokens === '*' && usedTokens.length) {\n throw new RangeError(\"The format string mustn't contain `\".concat(token, \"` and any other token at the same time\"));\n }\n\n usedTokens.push({\n token: firstCharacter,\n fullToken: token\n });\n var parseResult = parser.parse(dateString, token, locale.match, subFnOptions);\n\n if (!parseResult) {\n return new Date(NaN);\n }\n\n setters.push({\n priority: parser.priority,\n subPriority: parser.subPriority || 0,\n set: parser.set,\n validate: parser.validate,\n value: parseResult.value,\n index: setters.length\n });\n dateString = parseResult.rest;\n } else {\n if (firstCharacter.match(unescapedLatinCharacterRegExp)) {\n throw new RangeError('Format string contains an unescaped latin alphabet character `' + firstCharacter + '`');\n } // Replace two single quote characters with one single quote character\n\n\n if (token === \"''\") {\n token = \"'\";\n } else if (firstCharacter === \"'\") {\n token = cleanEscapedString(token);\n } // Cut token from string, or, if string doesn't match the token, return Invalid Date\n\n\n if (dateString.indexOf(token) === 0) {\n dateString = dateString.slice(token.length);\n } else {\n return new Date(NaN);\n }\n }\n } // Check if the remaining input contains something other than whitespace\n\n\n if (dateString.length > 0 && notWhitespaceRegExp.test(dateString)) {\n return new Date(NaN);\n }\n\n var uniquePrioritySetters = setters.map(function (setter) {\n return setter.priority;\n }).sort(function (a, b) {\n return b - a;\n }).filter(function (priority, index, array) {\n return array.indexOf(priority) === index;\n }).map(function (priority) {\n return setters.filter(function (setter) {\n return setter.priority === priority;\n }).sort(function (a, b) {\n return b.subPriority - a.subPriority;\n });\n }).map(function (setterArray) {\n return setterArray[0];\n });\n var date = toDate(dirtyReferenceDate);\n\n if (isNaN(date)) {\n return new Date(NaN);\n } // Convert the date in system timezone to the same date in UTC+00:00 timezone.\n // This ensures that when UTC functions will be implemented, locales will be compatible with them.\n // See an issue about UTC functions: https://github.com/date-fns/date-fns/issues/37\n\n\n var utcDate = subMilliseconds(date, getTimezoneOffsetInMilliseconds(date));\n var flags = {};\n\n for (i = 0; i < uniquePrioritySetters.length; i++) {\n var setter = uniquePrioritySetters[i];\n\n if (setter.validate && !setter.validate(utcDate, setter.value, subFnOptions)) {\n return new Date(NaN);\n }\n\n var result = setter.set(utcDate, flags, setter.value, subFnOptions); // Result is tuple (date, flags)\n\n if (result[0]) {\n utcDate = result[0];\n assign(flags, result[1]); // Result is date\n } else {\n utcDate = result;\n }\n }\n\n return utcDate;\n}\n\nfunction dateToSystemTimezone(date, flags) {\n if (flags.timestampIsSet) {\n return date;\n }\n\n var convertedDate = new Date(0);\n convertedDate.setFullYear(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());\n convertedDate.setHours(date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds());\n return convertedDate;\n}\n\nfunction cleanEscapedString(input) {\n return input.match(escapedStringRegExp)[1].replace(doubleQuoteRegExp, \"'\");\n}","export const showBadgeOnFavicon = () => {\n const favicons = document.querySelectorAll('.favicon');\n\n favicons.forEach(favicon => {\n const newFileName = `/favicon-badge-${favicon.sizes[[0]]}.png`;\n favicon.href = newFileName;\n });\n};\n\nexport const initFaviconSwitcher = () => {\n const favicons = document.querySelectorAll('.favicon');\n\n document.addEventListener('visibilitychange', () => {\n if (document.visibilityState === 'visible') {\n favicons.forEach(favicon => {\n const oldFileName = `/favicon-${favicon.sizes[[0]]}.png`;\n favicon.href = oldFileName;\n });\n }\n });\n};\n","import { MESSAGE_TYPE } from 'shared/constants/messages';\nimport { showBadgeOnFavicon } from './faviconHelper';\nimport { initFaviconSwitcher } from './faviconHelper';\nimport {\n getAlertAudio,\n initOnEvents,\n} from 'shared/helpers/AudioNotificationHelper';\n\nconst NOTIFICATION_TIME = 30000;\n\nclass DashboardAudioNotificationHelper {\n constructor() {\n this.recurringNotificationTimer = null;\n this.audioAlertType = 'none';\n this.playAlertOnlyWhenHidden = true;\n this.alertIfUnreadConversationExist = false;\n this.currentUserId = null;\n this.audioAlertTone = 'ding';\n }\n\n setInstanceValues = ({\n currentUserId,\n alwaysPlayAudioAlert,\n alertIfUnreadConversationExist,\n audioAlertType,\n audioAlertTone,\n }) => {\n this.audioAlertType = audioAlertType;\n this.playAlertOnlyWhenHidden = !alwaysPlayAudioAlert;\n this.alertIfUnreadConversationExist = alertIfUnreadConversationExist;\n this.currentUserId = currentUserId;\n this.audioAlertTone = audioAlertTone;\n initOnEvents.forEach(e => {\n document.addEventListener(e, this.onAudioListenEvent, false);\n });\n initFaviconSwitcher();\n };\n\n onAudioListenEvent = async () => {\n try {\n await getAlertAudio('', {\n type: 'dashboard',\n alertTone: this.audioAlertTone,\n });\n initOnEvents.forEach(event => {\n document.removeEventListener(event, this.onAudioListenEvent, false);\n });\n this.playAudioEvery30Seconds();\n } catch (error) {\n // Ignore audio fetch errors\n }\n };\n\n executeRecurringNotification = () => {\n if (!window.WOOT || !window.WOOT.$store) {\n this.clearSetTimeout();\n return;\n }\n const mineConversation = window.WOOT.$store.getters.getMineChats({\n assigneeType: 'me',\n status: 'open',\n });\n const hasUnreadConversation = mineConversation.some(conv => {\n return conv.unread_count > 0;\n });\n\n const shouldPlayAlert = !this.playAlertOnlyWhenHidden || document.hidden;\n\n if (hasUnreadConversation && shouldPlayAlert) {\n window.playAudioAlert();\n showBadgeOnFavicon();\n }\n this.clearSetTimeout();\n };\n\n clearSetTimeout = () => {\n if (this.recurringNotificationTimer) {\n clearTimeout(this.recurringNotificationTimer);\n }\n this.recurringNotificationTimer = setTimeout(\n this.executeRecurringNotification,\n NOTIFICATION_TIME\n );\n };\n\n playAudioEvery30Seconds = () => {\n // Audio alert is disabled dismiss the timer\n if (this.audioAlertType === 'none') {\n return;\n }\n // If assigned conversation flag is disabled dismiss the timer\n if (!this.alertIfUnreadConversationExist) {\n return;\n }\n\n this.clearSetTimeout();\n };\n\n isConversationAssignedToCurrentUser = message => {\n const conversationAssigneeId = message?.conversation?.assignee_id;\n return conversationAssigneeId === this.currentUserId;\n };\n\n // eslint-disable-next-line class-methods-use-this\n isMessageFromCurrentConversation = message => {\n return (\n window.WOOT.$store.getters.getSelectedChat?.id === message.conversation_id\n );\n };\n\n isMessageFromCurrentUser = message => {\n return message?.sender_id === this.currentUserId;\n };\n\n shouldNotifyOnMessage = message => {\n if (this.audioAlertType === 'mine') {\n return this.isConversationAssignedToCurrentUser(message);\n }\n return this.audioAlertType === 'all';\n };\n\n onNewMessage = message => {\n // If the message is sent by the current user or the\n // correct notification is not enabled, then dismiss the alert\n if (\n this.isMessageFromCurrentUser(message) ||\n !this.shouldNotifyOnMessage(message)\n ) {\n return;\n }\n\n // If the message type is not incoming or private, then dismiss the alert\n const { message_type: messageType, private: isPrivate } = message;\n if (messageType !== MESSAGE_TYPE.INCOMING && !isPrivate) {\n return;\n }\n\n // If the user looking at the conversation, then dismiss the alert\n if (this.isMessageFromCurrentConversation(message) && !document.hidden) {\n return;\n }\n // If the user has disabled alerts when active on the dashboard, the dismiss the alert\n if (this.playAlertOnlyWhenHidden && !document.hidden) {\n return;\n }\n\n window.playAudioAlert();\n showBadgeOnFavicon();\n this.playAudioEvery30Seconds();\n };\n}\n\nexport default new DashboardAudioNotificationHelper();\n","/**\n * Returns `process.env` if it is available in the environment.\n * Always returns an object make it similarly easy to use as `process.env`.\n */\nexport function getProcessEnv() {\n if (typeof process === 'undefined' || !process.env) {\n return {};\n }\n\n return process.env;\n}","import toDate from \"../toDate/index.js\";\nimport requiredArgs from \"../_lib/requiredArgs/index.js\";\n/**\n * @name getMinutes\n * @category Minute Helpers\n * @summary Get the minutes of the given date.\n *\n * @description\n * Get the minutes of the given date.\n *\n * ### v2.0.0 breaking changes:\n *\n * - [Changes that are common for the whole library](https://github.com/date-fns/date-fns/blob/master/docs/upgradeGuide.md#Common-Changes).\n *\n * @param {Date|Number} date - the given date\n * @returns {Number} the minutes\n * @throws {TypeError} 1 argument required\n *\n * @example\n * // Get the minutes of 29 February 2012 11:45:05:\n * const result = getMinutes(new Date(2012, 1, 29, 11, 45, 5))\n * //=> 45\n */\n\nexport default function getMinutes(dirtyDate) {\n requiredArgs(1, arguments);\n var date = toDate(dirtyDate);\n var minutes = date.getMinutes();\n return minutes;\n}","const sortListByOrder = (list) => {\n const sortedList = structuredClone(list);\n\n sortedList.sort((a, b) => a.order - b.order);\n\n sortedList.forEach((item) => {\n if (!Array.isArray(item.children)) {\n return;\n }\n\n item.children.sort((a, b) => a.order - b.order);\n });\n\n return sortedList;\n};\n\nconst mapFoldersAndItemsToListStructure = (folders, items) => {\n const clonedFolders = structuredClone(folders);\n const clonedItems = structuredClone(items);\n\n const result = clonedFolders.map((folder) => ({\n ...folder,\n children: [],\n }));\n\n clonedItems.forEach((item) => {\n if (!item.folderId) {\n result.push(item);\n return;\n }\n\n // eslint-disable-next-line no-underscore-dangle\n const matchedFolder = result.find((folder) => folder._id === item.folderId);\n\n if (!matchedFolder) {\n return;\n }\n\n matchedFolder.children.push(item);\n });\n\n const sorted = sortListByOrder(result);\n\n return {\n active: sorted.filter((item) => !item.isArchived),\n archived: sorted.filter((item) => item.isArchived),\n };\n};\n\nconst updateItemsAndFoldersKeys = (list) => {\n const clonedList = structuredClone(list);\n\n const newList = clonedList.map((item, index) => {\n item.order = index;\n\n if (!Array.isArray(item.children)) {\n item.folderId = '';\n return item;\n }\n\n item.children = structuredClone(\n item.children.map((child, childIndex) => {\n // eslint-disable-next-line no-underscore-dangle\n child.folderId = item.id || item._id;\n child.order = childIndex;\n return child;\n })\n );\n\n return item;\n });\n\n return newList;\n};\n\nconst mapListStructureToFoldersAndItems = (list) => {\n const clonedList = structuredClone(list);\n\n const items = [];\n const folders = [];\n\n clonedList.forEach((item) => {\n if (!Array.isArray(item.children)) {\n delete item.routeParams;\n items.push(item);\n return;\n }\n\n item.children.forEach((nestedItem) => {\n delete nestedItem.routeParams;\n items.push(nestedItem);\n });\n\n delete item.children;\n folders.push(item);\n });\n\n return {\n items,\n folders,\n };\n};\n\nexport {\n mapFoldersAndItemsToListStructure,\n updateItemsAndFoldersKeys,\n mapListStructureToFoldersAndItems,\n};\n","import { IS_DEBUG_BUILD } from './flags';\nimport { getGlobalObject } from './global';\nimport { logger } from './logger';\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\n\nexport function supportsErrorEvent() {\n try {\n new ErrorEvent('');\n return true;\n } catch (e) {\n return false;\n }\n}\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\n\nexport function supportsDOMError() {\n try {\n // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n // 1 argument required, but only 0 present.\n // @ts-ignore It really needs 1 argument, not 0.\n new DOMError('');\n return true;\n } catch (e) {\n return false;\n }\n}\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\n\nexport function supportsDOMException() {\n try {\n new DOMException('');\n return true;\n } catch (e) {\n return false;\n }\n}\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\n\nexport function supportsFetch() {\n if (!('fetch' in getGlobalObject())) {\n return false;\n }\n\n try {\n new Headers();\n new Request('');\n new Response();\n return true;\n } catch (e) {\n return false;\n }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\n\nexport function isNativeFetch(func) {\n return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\n\nexport function supportsNativeFetch() {\n if (!supportsFetch()) {\n return false;\n }\n\n var global = getGlobalObject(); // Fast path to avoid DOM I/O\n // eslint-disable-next-line @typescript-eslint/unbound-method\n\n if (isNativeFetch(global.fetch)) {\n return true;\n } // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)\n // so create a \"pure\" iframe to see if that has native fetch\n\n\n var result = false;\n var doc = global.document; // eslint-disable-next-line deprecation/deprecation\n\n if (doc && typeof doc.createElement === 'function') {\n try {\n var sandbox = doc.createElement('iframe');\n sandbox.hidden = true;\n doc.head.appendChild(sandbox);\n\n if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n // eslint-disable-next-line @typescript-eslint/unbound-method\n result = isNativeFetch(sandbox.contentWindow.fetch);\n }\n\n doc.head.removeChild(sandbox);\n } catch (err) {\n IS_DEBUG_BUILD && logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n }\n }\n\n return result;\n}\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\n\nexport function supportsReportingObserver() {\n return 'ReportingObserver' in getGlobalObject();\n}\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\n\nexport function supportsReferrerPolicy() {\n // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'\n // (see https://caniuse.com/#feat=referrer-policy),\n // it doesn't. And it throws an exception instead of ignoring this parameter...\n // REF: https://github.com/getsentry/raven-js/issues/1233\n if (!supportsFetch()) {\n return false;\n }\n\n try {\n new Request('_', {\n referrerPolicy: 'origin'\n });\n return true;\n } catch (e) {\n return false;\n }\n}\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\n\nexport function supportsHistory() {\n // NOTE: in Chrome App environment, touching history.pushState, *even inside\n // a try/catch block*, will cause Chrome to output an error to console.error\n // borrowed from: https://github.com/angular/angular.js/pull/13945/files\n var global = getGlobalObject();\n /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n var chrome = global.chrome;\n var isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n\n var hasHistoryApi = 'history' in global && !!global.history.pushState && !!global.history.replaceState;\n return !isChromePackagedApp && hasHistoryApi;\n}","import { __extends } from \"tslib\";\nimport { Emitter } from '../emitter';\nimport { backoff } from './backoff';\n/**\n * @internal\n */\n\nexport var ON_REMOVE_FROM_FUTURE = 'onRemoveFromFuture';\n\nvar PriorityQueue =\n/** @class */\nfunction (_super) {\n __extends(PriorityQueue, _super);\n\n function PriorityQueue(maxAttempts, queue, seen) {\n var _this = _super.call(this) || this;\n\n _this.future = [];\n _this.maxAttempts = maxAttempts;\n _this.queue = queue;\n _this.seen = seen !== null && seen !== void 0 ? seen : {};\n return _this;\n }\n\n PriorityQueue.prototype.push = function () {\n var _this = this;\n\n var items = [];\n\n for (var _i = 0; _i < arguments.length; _i++) {\n items[_i] = arguments[_i];\n }\n\n var accepted = items.map(function (operation) {\n var attempts = _this.updateAttempts(operation);\n\n if (attempts > _this.maxAttempts || _this.includes(operation)) {\n return false;\n }\n\n _this.queue.push(operation);\n\n return true;\n });\n this.queue = this.queue.sort(function (a, b) {\n return _this.getAttempts(a) - _this.getAttempts(b);\n });\n return accepted;\n };\n\n PriorityQueue.prototype.pushWithBackoff = function (item) {\n var _this = this;\n\n if (this.getAttempts(item) === 0) {\n return this.push(item)[0];\n }\n\n var attempt = this.updateAttempts(item);\n\n if (attempt > this.maxAttempts || this.includes(item)) {\n return false;\n }\n\n var timeout = backoff({\n attempt: attempt - 1\n });\n setTimeout(function () {\n _this.queue.push(item); // remove from future list\n\n\n _this.future = _this.future.filter(function (f) {\n return f.id !== item.id;\n }); // Lets listeners know that a 'future' message is now available in the queue\n\n _this.emit(ON_REMOVE_FROM_FUTURE);\n }, timeout);\n this.future.push(item);\n return true;\n };\n\n PriorityQueue.prototype.getAttempts = function (item) {\n var _a;\n\n return (_a = this.seen[item.id]) !== null && _a !== void 0 ? _a : 0;\n };\n\n PriorityQueue.prototype.updateAttempts = function (item) {\n this.seen[item.id] = this.getAttempts(item) + 1;\n return this.getAttempts(item);\n };\n\n PriorityQueue.prototype.includes = function (item) {\n return this.queue.includes(item) || this.future.includes(item) || Boolean(this.queue.find(function (i) {\n return i.id === item.id;\n })) || Boolean(this.future.find(function (i) {\n return i.id === item.id;\n }));\n };\n\n PriorityQueue.prototype.pop = function () {\n return this.queue.shift();\n };\n\n Object.defineProperty(PriorityQueue.prototype, \"length\", {\n get: function get() {\n return this.queue.length;\n },\n enumerable: false,\n configurable: true\n });\n Object.defineProperty(PriorityQueue.prototype, \"todo\", {\n get: function get() {\n return this.queue.length + this.future.length;\n },\n enumerable: false,\n configurable: true\n });\n return PriorityQueue;\n}(Emitter);\n\nexport { PriorityQueue };","export function backoff(params) {\n var random = Math.random() + 1;\n var _a = params.minTimeout,\n minTimeout = _a === void 0 ? 500 : _a,\n _b = params.factor,\n factor = _b === void 0 ? 2 : _b,\n attempt = params.attempt,\n _c = params.maxTimeout,\n maxTimeout = _c === void 0 ? Infinity : _c;\n return Math.min(random * minTimeout * Math.pow(factor, attempt), maxTimeout);\n}","/* global axios */\n\nimport PortalsAPI from './portals';\nimport { getArticleSearchURL } from 'dashboard/helper/URLHelper.js';\n\nclass ArticlesAPI extends PortalsAPI {\n constructor() {\n super('articles', { accountScoped: true });\n }\n\n getArticles({\n pageNumber,\n portalSlug,\n locale,\n status,\n authorId,\n categorySlug,\n sort,\n }) {\n const url = getArticleSearchURL({\n pageNumber,\n portalSlug,\n locale,\n status,\n authorId,\n categorySlug,\n sort,\n host: this.url,\n });\n\n return axios.get(url);\n }\n\n searchArticles({ portalSlug, query }) {\n const url = getArticleSearchURL({\n portalSlug,\n query,\n host: this.url,\n });\n return axios.get(url);\n }\n\n getArticle({ id, portalSlug }) {\n return axios.get(`${this.url}/${portalSlug}/articles/${id}`);\n }\n\n updateArticle({ portalSlug, articleId, articleObj }) {\n return axios.patch(\n `${this.url}/${portalSlug}/articles/${articleId}`,\n articleObj\n );\n }\n\n createArticle({ portalSlug, articleObj }) {\n const { content, title, author_id, category_id } = articleObj;\n return axios.post(`${this.url}/${portalSlug}/articles`, {\n content,\n title,\n author_id,\n category_id,\n });\n }\n\n deleteArticle({ articleId, portalSlug }) {\n return axios.delete(`${this.url}/${portalSlug}/articles/${articleId}`);\n }\n\n reorderArticles({ portalSlug, reorderedGroup, categorySlug }) {\n return axios.post(`${this.url}/${portalSlug}/articles/reorder`, {\n positions_hash: reorderedGroup,\n category_slug: categorySlug,\n });\n }\n}\n\nexport default new ArticlesAPI();\n","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _iterableToArray(iter) { if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nimport { Parser, NodeProp, NodeSet, NodeType, DefaultBufferLength, Tree, IterMode } from '@lezer/common';\n/**\nA parse stack. These are used internally by the parser to track\nparsing progress. They also provide some properties and methods\nthat external code such as a tokenizer can use to get information\nabout the parse state.\n*/\n\nvar Stack = /*#__PURE__*/function () {\n /**\n @internal\n */\n function Stack(\n /**\n The parse that this stack is part of @internal\n */\n p,\n /**\n Holds state, input pos, buffer index triplets for all but the\n top state @internal\n */\n stack,\n /**\n The current parse state @internal\n */\n state, // The position at which the next reduce should take place. This\n // can be less than `this.pos` when skipped expressions have been\n // added to the stack (which should be moved outside of the next\n // reduction)\n\n /**\n @internal\n */\n reducePos,\n /**\n The input position up to which this stack has parsed.\n */\n pos,\n /**\n The dynamic score of the stack, including dynamic precedence\n and error-recovery penalties\n @internal\n */\n score, // The output buffer. Holds (type, start, end, size) quads\n // representing nodes created by the parser, where `size` is\n // amount of buffer array entries covered by this node.\n\n /**\n @internal\n */\n buffer, // The base offset of the buffer. When stacks are split, the split\n // instance shared the buffer history with its parent up to\n // `bufferBase`, which is the absolute offset (including the\n // offset of previous splits) into the buffer at which this stack\n // starts writing.\n\n /**\n @internal\n */\n bufferBase,\n /**\n @internal\n */\n curContext) {\n var lookAhead = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : 0;\n var // A parent stack from which this was split off, if any. This is\n // set up so that it always points to a stack that has some\n // additional buffer content, never to a stack with an equal\n // `bufferBase`.\n\n /**\n @internal\n */\n parent = arguments.length > 10 ? arguments[10] : undefined;\n\n _classCallCheck(this, Stack);\n\n this.p = p;\n this.stack = stack;\n this.state = state;\n this.reducePos = reducePos;\n this.pos = pos;\n this.score = score;\n this.buffer = buffer;\n this.bufferBase = bufferBase;\n this.curContext = curContext;\n this.lookAhead = lookAhead;\n this.parent = parent;\n }\n /**\n @internal\n */\n\n\n _createClass(Stack, [{\n key: \"toString\",\n value: function toString() {\n return \"[\".concat(this.stack.filter(function (_, i) {\n return i % 3 == 0;\n }).concat(this.state), \"]@\").concat(this.pos).concat(this.score ? \"!\" + this.score : \"\");\n } // Start an empty stack\n\n /**\n @internal\n */\n\n }, {\n key: \"context\",\n get:\n /**\n The stack's current [context](#lr.ContextTracker) value, if\n any. Its type will depend on the context tracker's type\n parameter, or it will be `null` if there is no context\n tracker.\n */\n function get() {\n return this.curContext ? this.curContext.context : null;\n } // Push a state onto the stack, tracking its start position as well\n // as the buffer base at that point.\n\n /**\n @internal\n */\n\n }, {\n key: \"pushState\",\n value: function pushState(state, start) {\n this.stack.push(this.state, start, this.bufferBase + this.buffer.length);\n this.state = state;\n } // Apply a reduce action\n\n /**\n @internal\n */\n\n }, {\n key: \"reduce\",\n value: function reduce(action) {\n var _a;\n\n var depth = action >> 19\n /* Action.ReduceDepthShift */\n ,\n type = action & 65535\n /* Action.ValueMask */\n ;\n var parser = this.p.parser;\n var dPrec = parser.dynamicPrecedence(type);\n if (dPrec) this.score += dPrec;\n\n if (depth == 0) {\n this.pushState(parser.getGoto(this.state, type, true), this.reducePos); // Zero-depth reductions are a special case—they add stuff to\n // the stack without popping anything off.\n\n if (type < parser.minRepeatTerm) this.storeNode(type, this.reducePos, this.reducePos, 4, true);\n this.reduceContext(type, this.reducePos);\n return;\n } // Find the base index into `this.stack`, content after which will\n // be dropped. Note that with `StayFlag` reductions we need to\n // consume two extra frames (the dummy parent node for the skipped\n // expression and the state that we'll be staying in, which should\n // be moved to `this.state`).\n\n\n var base = this.stack.length - (depth - 1) * 3 - (action & 262144\n /* Action.StayFlag */\n ? 6 : 0);\n var start = base ? this.stack[base - 2] : this.p.ranges[0].from,\n size = this.reducePos - start; // This is a kludge to try and detect overly deep left-associative\n // trees, which will not increase the parse stack depth and thus\n // won't be caught by the regular stack-depth limit check.\n\n if (size >= 2000\n /* Recover.MinBigReduction */\n && !((_a = this.p.parser.nodeSet.types[type]) === null || _a === void 0 ? void 0 : _a.isAnonymous)) {\n if (start == this.p.lastBigReductionStart) {\n this.p.bigReductionCount++;\n this.p.lastBigReductionSize = size;\n } else if (this.p.lastBigReductionSize < size) {\n this.p.bigReductionCount = 1;\n this.p.lastBigReductionStart = start;\n this.p.lastBigReductionSize = size;\n }\n }\n\n var bufferBase = base ? this.stack[base - 1] : 0,\n count = this.bufferBase + this.buffer.length - bufferBase; // Store normal terms or `R -> R R` repeat reductions\n\n if (type < parser.minRepeatTerm || action & 131072\n /* Action.RepeatFlag */\n ) {\n var pos = parser.stateFlag(this.state, 1\n /* StateFlag.Skipped */\n ) ? this.pos : this.reducePos;\n this.storeNode(type, start, pos, count + 4, true);\n }\n\n if (action & 262144\n /* Action.StayFlag */\n ) {\n this.state = this.stack[base];\n } else {\n var baseStateID = this.stack[base - 3];\n this.state = parser.getGoto(baseStateID, type, true);\n }\n\n while (this.stack.length > base) {\n this.stack.pop();\n }\n\n this.reduceContext(type, start);\n } // Shift a value into the buffer\n\n /**\n @internal\n */\n\n }, {\n key: \"storeNode\",\n value: function storeNode(term, start, end) {\n var size = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 4;\n var isReduce = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n\n if (term == 0\n /* Term.Err */\n && (!this.stack.length || this.stack[this.stack.length - 1] < this.buffer.length + this.bufferBase)) {\n // Try to omit/merge adjacent error nodes\n var cur = this,\n top = this.buffer.length;\n\n if (top == 0 && cur.parent) {\n top = cur.bufferBase - cur.parent.bufferBase;\n cur = cur.parent;\n }\n\n if (top > 0 && cur.buffer[top - 4] == 0\n /* Term.Err */\n && cur.buffer[top - 1] > -1) {\n if (start == end) return;\n\n if (cur.buffer[top - 2] >= start) {\n cur.buffer[top - 2] = end;\n return;\n }\n }\n }\n\n if (!isReduce || this.pos == end) {\n // Simple case, just append\n this.buffer.push(term, start, end, size);\n } else {\n // There may be skipped nodes that have to be moved forward\n var index = this.buffer.length;\n if (index > 0 && this.buffer[index - 4] != 0\n /* Term.Err */\n ) while (index > 0 && this.buffer[index - 2] > end) {\n // Move this record forward\n this.buffer[index] = this.buffer[index - 4];\n this.buffer[index + 1] = this.buffer[index - 3];\n this.buffer[index + 2] = this.buffer[index - 2];\n this.buffer[index + 3] = this.buffer[index - 1];\n index -= 4;\n if (size > 4) size -= 4;\n }\n this.buffer[index] = term;\n this.buffer[index + 1] = start;\n this.buffer[index + 2] = end;\n this.buffer[index + 3] = size;\n }\n } // Apply a shift action\n\n /**\n @internal\n */\n\n }, {\n key: \"shift\",\n value: function shift(action, type, start, end) {\n if (action & 131072\n /* Action.GotoFlag */\n ) {\n this.pushState(action & 65535\n /* Action.ValueMask */\n , this.pos);\n } else if ((action & 262144\n /* Action.StayFlag */\n ) == 0) {\n // Regular shift\n var nextState = action,\n parser = this.p.parser;\n\n if (end > this.pos || type <= parser.maxNode) {\n this.pos = end;\n if (!parser.stateFlag(nextState, 1\n /* StateFlag.Skipped */\n )) this.reducePos = end;\n }\n\n this.pushState(nextState, start);\n this.shiftContext(type, start);\n if (type <= parser.maxNode) this.buffer.push(type, start, end, 4);\n } else {\n // Shift-and-stay, which means this is a skipped token\n this.pos = end;\n this.shiftContext(type, start);\n if (type <= this.p.parser.maxNode) this.buffer.push(type, start, end, 4);\n }\n } // Apply an action\n\n /**\n @internal\n */\n\n }, {\n key: \"apply\",\n value: function apply(action, next, nextStart, nextEnd) {\n if (action & 65536\n /* Action.ReduceFlag */\n ) this.reduce(action);else this.shift(action, next, nextStart, nextEnd);\n } // Add a prebuilt (reused) node into the buffer.\n\n /**\n @internal\n */\n\n }, {\n key: \"useNode\",\n value: function useNode(value, next) {\n var index = this.p.reused.length - 1;\n\n if (index < 0 || this.p.reused[index] != value) {\n this.p.reused.push(value);\n index++;\n }\n\n var start = this.pos;\n this.reducePos = this.pos = start + value.length;\n this.pushState(next, start);\n this.buffer.push(index, start, this.reducePos, -1\n /* size == -1 means this is a reused value */\n );\n if (this.curContext) this.updateContext(this.curContext.tracker.reuse(this.curContext.context, value, this, this.p.stream.reset(this.pos - value.length)));\n } // Split the stack. Due to the buffer sharing and the fact\n // that `this.stack` tends to stay quite shallow, this isn't very\n // expensive.\n\n /**\n @internal\n */\n\n }, {\n key: \"split\",\n value: function split() {\n var parent = this;\n var off = parent.buffer.length; // Because the top of the buffer (after this.pos) may be mutated\n // to reorder reductions and skipped tokens, and shared buffers\n // should be immutable, this copies any outstanding skipped tokens\n // to the new buffer, and puts the base pointer before them.\n\n while (off > 0 && parent.buffer[off - 2] > parent.reducePos) {\n off -= 4;\n }\n\n var buffer = parent.buffer.slice(off),\n base = parent.bufferBase + off; // Make sure parent points to an actual parent with content, if there is such a parent.\n\n while (parent && base == parent.bufferBase) {\n parent = parent.parent;\n }\n\n return new Stack(this.p, this.stack.slice(), this.state, this.reducePos, this.pos, this.score, buffer, base, this.curContext, this.lookAhead, parent);\n } // Try to recover from an error by 'deleting' (ignoring) one token.\n\n /**\n @internal\n */\n\n }, {\n key: \"recoverByDelete\",\n value: function recoverByDelete(next, nextEnd) {\n var isNode = next <= this.p.parser.maxNode;\n if (isNode) this.storeNode(next, this.pos, nextEnd, 4);\n this.storeNode(0\n /* Term.Err */\n , this.pos, nextEnd, isNode ? 8 : 4);\n this.pos = this.reducePos = nextEnd;\n this.score -= 190\n /* Recover.Delete */\n ;\n }\n /**\n Check if the given term would be able to be shifted (optionally\n after some reductions) on this stack. This can be useful for\n external tokenizers that want to make sure they only provide a\n given token when it applies.\n */\n\n }, {\n key: \"canShift\",\n value: function canShift(term) {\n for (var sim = new SimulatedStack(this);;) {\n var action = this.p.parser.stateSlot(sim.state, 4\n /* ParseState.DefaultReduce */\n ) || this.p.parser.hasAction(sim.state, term);\n if (action == 0) return false;\n if ((action & 65536\n /* Action.ReduceFlag */\n ) == 0) return true;\n sim.reduce(action);\n }\n } // Apply up to Recover.MaxNext recovery actions that conceptually\n // inserts some missing token or rule.\n\n /**\n @internal\n */\n\n }, {\n key: \"recoverByInsert\",\n value: function recoverByInsert(next) {\n if (this.stack.length >= 300\n /* Recover.MaxInsertStackDepth */\n ) return [];\n var nextStates = this.p.parser.nextStates(this.state);\n\n if (nextStates.length > 4\n /* Recover.MaxNext */\n << 1 || this.stack.length >= 120\n /* Recover.DampenInsertStackDepth */\n ) {\n var best = [];\n\n for (var i = 0, s; i < nextStates.length; i += 2) {\n if ((s = nextStates[i + 1]) != this.state && this.p.parser.hasAction(s, next)) best.push(nextStates[i], s);\n }\n\n if (this.stack.length < 120\n /* Recover.DampenInsertStackDepth */\n ) {\n var _loop = function _loop(_i) {\n var s = nextStates[_i + 1];\n if (!best.some(function (v, i) {\n return i & 1 && v == s;\n })) best.push(nextStates[_i], s);\n };\n\n for (var _i = 0; best.length < 4\n /* Recover.MaxNext */\n << 1 && _i < nextStates.length; _i += 2) {\n _loop(_i);\n }\n }\n\n nextStates = best;\n }\n\n var result = [];\n\n for (var _i2 = 0; _i2 < nextStates.length && result.length < 4\n /* Recover.MaxNext */\n ; _i2 += 2) {\n var _s = nextStates[_i2 + 1];\n if (_s == this.state) continue;\n var stack = this.split();\n stack.pushState(_s, this.pos);\n stack.storeNode(0\n /* Term.Err */\n , stack.pos, stack.pos, 4, true);\n stack.shiftContext(nextStates[_i2], this.pos);\n stack.reducePos = this.pos;\n stack.score -= 200\n /* Recover.Insert */\n ;\n result.push(stack);\n }\n\n return result;\n } // Force a reduce, if possible. Return false if that can't\n // be done.\n\n /**\n @internal\n */\n\n }, {\n key: \"forceReduce\",\n value: function forceReduce() {\n var parser = this.p.parser;\n var reduce = parser.stateSlot(this.state, 5\n /* ParseState.ForcedReduce */\n );\n if ((reduce & 65536\n /* Action.ReduceFlag */\n ) == 0) return false;\n\n if (!parser.validAction(this.state, reduce)) {\n var depth = reduce >> 19\n /* Action.ReduceDepthShift */\n ,\n term = reduce & 65535\n /* Action.ValueMask */\n ;\n var target = this.stack.length - depth * 3;\n\n if (target < 0 || parser.getGoto(this.stack[target], term, false) < 0) {\n var backup = this.findForcedReduction();\n if (backup == null) return false;\n reduce = backup;\n }\n\n this.storeNode(0\n /* Term.Err */\n , this.pos, this.pos, 4, true);\n this.score -= 100\n /* Recover.Reduce */\n ;\n }\n\n this.reducePos = this.pos;\n this.reduce(reduce);\n return true;\n }\n /**\n Try to scan through the automaton to find some kind of reduction\n that can be applied. Used when the regular ForcedReduce field\n isn't a valid action. @internal\n */\n\n }, {\n key: \"findForcedReduction\",\n value: function findForcedReduction() {\n var _this = this;\n\n var parser = this.p.parser,\n seen = [];\n\n var explore = function explore(state, depth) {\n if (seen.includes(state)) return;\n seen.push(state);\n return parser.allActions(state, function (action) {\n if (action & (262144\n /* Action.StayFlag */\n | 131072\n /* Action.GotoFlag */\n )) ;else if (action & 65536\n /* Action.ReduceFlag */\n ) {\n var rDepth = (action >> 19\n /* Action.ReduceDepthShift */\n ) - depth;\n\n if (rDepth > 1) {\n var term = action & 65535\n /* Action.ValueMask */\n ,\n target = _this.stack.length - rDepth * 3;\n if (target >= 0 && parser.getGoto(_this.stack[target], term, false) >= 0) return rDepth << 19\n /* Action.ReduceDepthShift */\n | 65536\n /* Action.ReduceFlag */\n | term;\n }\n } else {\n var found = explore(action, depth + 1);\n if (found != null) return found;\n }\n });\n };\n\n return explore(this.state, 0);\n }\n /**\n @internal\n */\n\n }, {\n key: \"forceAll\",\n value: function forceAll() {\n while (!this.p.parser.stateFlag(this.state, 2\n /* StateFlag.Accepting */\n )) {\n if (!this.forceReduce()) {\n this.storeNode(0\n /* Term.Err */\n , this.pos, this.pos, 4, true);\n break;\n }\n }\n\n return this;\n }\n /**\n Check whether this state has no further actions (assumed to be a direct descendant of the\n top state, since any other states must be able to continue\n somehow). @internal\n */\n\n }, {\n key: \"deadEnd\",\n get: function get() {\n if (this.stack.length != 3) return false;\n var parser = this.p.parser;\n return parser.data[parser.stateSlot(this.state, 1\n /* ParseState.Actions */\n )] == 65535\n /* Seq.End */\n && !parser.stateSlot(this.state, 4\n /* ParseState.DefaultReduce */\n );\n }\n /**\n Restart the stack (put it back in its start state). Only safe\n when this.stack.length == 3 (state is directly below the top\n state). @internal\n */\n\n }, {\n key: \"restart\",\n value: function restart() {\n this.storeNode(0\n /* Term.Err */\n , this.pos, this.pos, 4, true);\n this.state = this.stack[0];\n this.stack.length = 0;\n }\n /**\n @internal\n */\n\n }, {\n key: \"sameState\",\n value: function sameState(other) {\n if (this.state != other.state || this.stack.length != other.stack.length) return false;\n\n for (var i = 0; i < this.stack.length; i += 3) {\n if (this.stack[i] != other.stack[i]) return false;\n }\n\n return true;\n }\n /**\n Get the parser used by this stack.\n */\n\n }, {\n key: \"parser\",\n get: function get() {\n return this.p.parser;\n }\n /**\n Test whether a given dialect (by numeric ID, as exported from\n the terms file) is enabled.\n */\n\n }, {\n key: \"dialectEnabled\",\n value: function dialectEnabled(dialectID) {\n return this.p.parser.dialect.flags[dialectID];\n }\n }, {\n key: \"shiftContext\",\n value: function shiftContext(term, start) {\n if (this.curContext) this.updateContext(this.curContext.tracker.shift(this.curContext.context, term, this, this.p.stream.reset(start)));\n }\n }, {\n key: \"reduceContext\",\n value: function reduceContext(term, start) {\n if (this.curContext) this.updateContext(this.curContext.tracker.reduce(this.curContext.context, term, this, this.p.stream.reset(start)));\n }\n /**\n @internal\n */\n\n }, {\n key: \"emitContext\",\n value: function emitContext() {\n var last = this.buffer.length - 1;\n if (last < 0 || this.buffer[last] != -3) this.buffer.push(this.curContext.hash, this.pos, this.pos, -3);\n }\n /**\n @internal\n */\n\n }, {\n key: \"emitLookAhead\",\n value: function emitLookAhead() {\n var last = this.buffer.length - 1;\n if (last < 0 || this.buffer[last] != -4) this.buffer.push(this.lookAhead, this.pos, this.pos, -4);\n }\n }, {\n key: \"updateContext\",\n value: function updateContext(context) {\n if (context != this.curContext.context) {\n var newCx = new StackContext(this.curContext.tracker, context);\n if (newCx.hash != this.curContext.hash) this.emitContext();\n this.curContext = newCx;\n }\n }\n /**\n @internal\n */\n\n }, {\n key: \"setLookAhead\",\n value: function setLookAhead(lookAhead) {\n if (lookAhead > this.lookAhead) {\n this.emitLookAhead();\n this.lookAhead = lookAhead;\n }\n }\n /**\n @internal\n */\n\n }, {\n key: \"close\",\n value: function close() {\n if (this.curContext && this.curContext.tracker.strict) this.emitContext();\n if (this.lookAhead > 0) this.emitLookAhead();\n }\n }], [{\n key: \"start\",\n value: function start(p, state) {\n var pos = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n var cx = p.parser.context;\n return new Stack(p, [], state, pos, pos, 0, [], 0, cx ? new StackContext(cx, cx.start) : null, 0, null);\n }\n }]);\n\n return Stack;\n}();\n\nvar StackContext = function StackContext(tracker, context) {\n _classCallCheck(this, StackContext);\n\n this.tracker = tracker;\n this.context = context;\n this.hash = tracker.strict ? tracker.hash(context) : 0;\n}; // Used to cheaply run some reductions to scan ahead without mutating\n// an entire stack\n\n\nvar SimulatedStack = /*#__PURE__*/function () {\n function SimulatedStack(start) {\n _classCallCheck(this, SimulatedStack);\n\n this.start = start;\n this.state = start.state;\n this.stack = start.stack;\n this.base = this.stack.length;\n }\n\n _createClass(SimulatedStack, [{\n key: \"reduce\",\n value: function reduce(action) {\n var term = action & 65535\n /* Action.ValueMask */\n ,\n depth = action >> 19\n /* Action.ReduceDepthShift */\n ;\n\n if (depth == 0) {\n if (this.stack == this.start.stack) this.stack = this.stack.slice();\n this.stack.push(this.state, 0, 0);\n this.base += 3;\n } else {\n this.base -= (depth - 1) * 3;\n }\n\n var goto = this.start.p.parser.getGoto(this.stack[this.base - 3], term, true);\n this.state = goto;\n }\n }]);\n\n return SimulatedStack;\n}(); // This is given to `Tree.build` to build a buffer, and encapsulates\n// the parent-stack-walking necessary to read the nodes.\n\n\nvar StackBufferCursor = /*#__PURE__*/function () {\n function StackBufferCursor(stack, pos, index) {\n _classCallCheck(this, StackBufferCursor);\n\n this.stack = stack;\n this.pos = pos;\n this.index = index;\n this.buffer = stack.buffer;\n if (this.index == 0) this.maybeNext();\n }\n\n _createClass(StackBufferCursor, [{\n key: \"maybeNext\",\n value: function maybeNext() {\n var next = this.stack.parent;\n\n if (next != null) {\n this.index = this.stack.bufferBase - next.bufferBase;\n this.stack = next;\n this.buffer = next.buffer;\n }\n }\n }, {\n key: \"id\",\n get: function get() {\n return this.buffer[this.index - 4];\n }\n }, {\n key: \"start\",\n get: function get() {\n return this.buffer[this.index - 3];\n }\n }, {\n key: \"end\",\n get: function get() {\n return this.buffer[this.index - 2];\n }\n }, {\n key: \"size\",\n get: function get() {\n return this.buffer[this.index - 1];\n }\n }, {\n key: \"next\",\n value: function next() {\n this.index -= 4;\n this.pos -= 4;\n if (this.index == 0) this.maybeNext();\n }\n }, {\n key: \"fork\",\n value: function fork() {\n return new StackBufferCursor(this.stack, this.pos, this.index);\n }\n }], [{\n key: \"create\",\n value: function create(stack) {\n var pos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : stack.bufferBase + stack.buffer.length;\n return new StackBufferCursor(stack, pos, pos - stack.bufferBase);\n }\n }]);\n\n return StackBufferCursor;\n}(); // See lezer-generator/src/encode.ts for comments about the encoding\n// used here\n\n\nfunction decodeArray(input) {\n var Type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Uint16Array;\n if (typeof input != \"string\") return input;\n var array = null;\n\n for (var pos = 0, out = 0; pos < input.length;) {\n var value = 0;\n\n for (;;) {\n var next = input.charCodeAt(pos++),\n stop = false;\n\n if (next == 126\n /* Encode.BigValCode */\n ) {\n value = 65535\n /* Encode.BigVal */\n ;\n break;\n }\n\n if (next >= 92\n /* Encode.Gap2 */\n ) next--;\n if (next >= 34\n /* Encode.Gap1 */\n ) next--;\n var digit = next - 32\n /* Encode.Start */\n ;\n\n if (digit >= 46\n /* Encode.Base */\n ) {\n digit -= 46\n /* Encode.Base */\n ;\n stop = true;\n }\n\n value += digit;\n if (stop) break;\n value *= 46\n /* Encode.Base */\n ;\n }\n\n if (array) array[out++] = value;else array = new Type(value);\n }\n\n return array;\n}\n\nvar CachedToken = function CachedToken() {\n _classCallCheck(this, CachedToken);\n\n this.start = -1;\n this.value = -1;\n this.end = -1;\n this.extended = -1;\n this.lookAhead = 0;\n this.mask = 0;\n this.context = 0;\n};\n\nvar nullToken = new CachedToken();\n/**\n[Tokenizers](#lr.ExternalTokenizer) interact with the input\nthrough this interface. It presents the input as a stream of\ncharacters, tracking lookahead and hiding the complexity of\n[ranges](#common.Parser.parse^ranges) from tokenizer code.\n*/\n\nvar InputStream = /*#__PURE__*/function () {\n /**\n @internal\n */\n function InputStream(\n /**\n @internal\n */\n input,\n /**\n @internal\n */\n ranges) {\n _classCallCheck(this, InputStream);\n\n this.input = input;\n this.ranges = ranges;\n /**\n @internal\n */\n\n this.chunk = \"\";\n /**\n @internal\n */\n\n this.chunkOff = 0;\n /**\n Backup chunk\n */\n\n this.chunk2 = \"\";\n this.chunk2Pos = 0;\n /**\n The character code of the next code unit in the input, or -1\n when the stream is at the end of the input.\n */\n\n this.next = -1;\n /**\n @internal\n */\n\n this.token = nullToken;\n this.rangeIndex = 0;\n this.pos = this.chunkPos = ranges[0].from;\n this.range = ranges[0];\n this.end = ranges[ranges.length - 1].to;\n this.readNext();\n }\n /**\n @internal\n */\n\n\n _createClass(InputStream, [{\n key: \"resolveOffset\",\n value: function resolveOffset(offset, assoc) {\n var range = this.range,\n index = this.rangeIndex;\n var pos = this.pos + offset;\n\n while (pos < range.from) {\n if (!index) return null;\n var next = this.ranges[--index];\n pos -= range.from - next.to;\n range = next;\n }\n\n while (assoc < 0 ? pos > range.to : pos >= range.to) {\n if (index == this.ranges.length - 1) return null;\n var _next = this.ranges[++index];\n pos += _next.from - range.to;\n range = _next;\n }\n\n return pos;\n }\n /**\n @internal\n */\n\n }, {\n key: \"clipPos\",\n value: function clipPos(pos) {\n if (pos >= this.range.from && pos < this.range.to) return pos;\n\n var _iterator = _createForOfIteratorHelper(this.ranges),\n _step;\n\n try {\n for (_iterator.s(); !(_step = _iterator.n()).done;) {\n var range = _step.value;\n if (range.to > pos) return Math.max(pos, range.from);\n }\n } catch (err) {\n _iterator.e(err);\n } finally {\n _iterator.f();\n }\n\n return this.end;\n }\n /**\n Look at a code unit near the stream position. `.peek(0)` equals\n `.next`, `.peek(-1)` gives you the previous character, and so\n on.\n \n Note that looking around during tokenizing creates dependencies\n on potentially far-away content, which may reduce the\n effectiveness incremental parsing—when looking forward—or even\n cause invalid reparses when looking backward more than 25 code\n units, since the library does not track lookbehind.\n */\n\n }, {\n key: \"peek\",\n value: function peek(offset) {\n var idx = this.chunkOff + offset,\n pos,\n result;\n\n if (idx >= 0 && idx < this.chunk.length) {\n pos = this.pos + offset;\n result = this.chunk.charCodeAt(idx);\n } else {\n var resolved = this.resolveOffset(offset, 1);\n if (resolved == null) return -1;\n pos = resolved;\n\n if (pos >= this.chunk2Pos && pos < this.chunk2Pos + this.chunk2.length) {\n result = this.chunk2.charCodeAt(pos - this.chunk2Pos);\n } else {\n var i = this.rangeIndex,\n range = this.range;\n\n while (range.to <= pos) {\n range = this.ranges[++i];\n }\n\n this.chunk2 = this.input.chunk(this.chunk2Pos = pos);\n if (pos + this.chunk2.length > range.to) this.chunk2 = this.chunk2.slice(0, range.to - pos);\n result = this.chunk2.charCodeAt(0);\n }\n }\n\n if (pos >= this.token.lookAhead) this.token.lookAhead = pos + 1;\n return result;\n }\n /**\n Accept a token. By default, the end of the token is set to the\n current stream position, but you can pass an offset (relative to\n the stream position) to change that.\n */\n\n }, {\n key: \"acceptToken\",\n value: function acceptToken(token) {\n var endOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n var end = endOffset ? this.resolveOffset(endOffset, -1) : this.pos;\n if (end == null || end < this.token.start) throw new RangeError(\"Token end out of bounds\");\n this.token.value = token;\n this.token.end = end;\n }\n /**\n Accept a token ending at a specific given position.\n */\n\n }, {\n key: \"acceptTokenTo\",\n value: function acceptTokenTo(token, endPos) {\n this.token.value = token;\n this.token.end = endPos;\n }\n }, {\n key: \"getChunk\",\n value: function getChunk() {\n if (this.pos >= this.chunk2Pos && this.pos < this.chunk2Pos + this.chunk2.length) {\n var chunk = this.chunk,\n chunkPos = this.chunkPos;\n this.chunk = this.chunk2;\n this.chunkPos = this.chunk2Pos;\n this.chunk2 = chunk;\n this.chunk2Pos = chunkPos;\n this.chunkOff = this.pos - this.chunkPos;\n } else {\n this.chunk2 = this.chunk;\n this.chunk2Pos = this.chunkPos;\n var nextChunk = this.input.chunk(this.pos);\n var end = this.pos + nextChunk.length;\n this.chunk = end > this.range.to ? nextChunk.slice(0, this.range.to - this.pos) : nextChunk;\n this.chunkPos = this.pos;\n this.chunkOff = 0;\n }\n }\n }, {\n key: \"readNext\",\n value: function readNext() {\n if (this.chunkOff >= this.chunk.length) {\n this.getChunk();\n if (this.chunkOff == this.chunk.length) return this.next = -1;\n }\n\n return this.next = this.chunk.charCodeAt(this.chunkOff);\n }\n /**\n Move the stream forward N (defaults to 1) code units. Returns\n the new value of [`next`](#lr.InputStream.next).\n */\n\n }, {\n key: \"advance\",\n value: function advance() {\n var n = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;\n this.chunkOff += n;\n\n while (this.pos + n >= this.range.to) {\n if (this.rangeIndex == this.ranges.length - 1) return this.setDone();\n n -= this.range.to - this.pos;\n this.range = this.ranges[++this.rangeIndex];\n this.pos = this.range.from;\n }\n\n this.pos += n;\n if (this.pos >= this.token.lookAhead) this.token.lookAhead = this.pos + 1;\n return this.readNext();\n }\n }, {\n key: \"setDone\",\n value: function setDone() {\n this.pos = this.chunkPos = this.end;\n this.range = this.ranges[this.rangeIndex = this.ranges.length - 1];\n this.chunk = \"\";\n return this.next = -1;\n }\n /**\n @internal\n */\n\n }, {\n key: \"reset\",\n value: function reset(pos, token) {\n if (token) {\n this.token = token;\n token.start = pos;\n token.lookAhead = pos + 1;\n token.value = token.extended = -1;\n } else {\n this.token = nullToken;\n }\n\n if (this.pos != pos) {\n this.pos = pos;\n\n if (pos == this.end) {\n this.setDone();\n return this;\n }\n\n while (pos < this.range.from) {\n this.range = this.ranges[--this.rangeIndex];\n }\n\n while (pos >= this.range.to) {\n this.range = this.ranges[++this.rangeIndex];\n }\n\n if (pos >= this.chunkPos && pos < this.chunkPos + this.chunk.length) {\n this.chunkOff = pos - this.chunkPos;\n } else {\n this.chunk = \"\";\n this.chunkOff = 0;\n }\n\n this.readNext();\n }\n\n return this;\n }\n /**\n @internal\n */\n\n }, {\n key: \"read\",\n value: function read(from, to) {\n if (from >= this.chunkPos && to <= this.chunkPos + this.chunk.length) return this.chunk.slice(from - this.chunkPos, to - this.chunkPos);\n if (from >= this.chunk2Pos && to <= this.chunk2Pos + this.chunk2.length) return this.chunk2.slice(from - this.chunk2Pos, to - this.chunk2Pos);\n if (from >= this.range.from && to <= this.range.to) return this.input.read(from, to);\n var result = \"\";\n\n var _iterator2 = _createForOfIteratorHelper(this.ranges),\n _step2;\n\n try {\n for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n var r = _step2.value;\n if (r.from >= to) break;\n if (r.to > from) result += this.input.read(Math.max(r.from, from), Math.min(r.to, to));\n }\n } catch (err) {\n _iterator2.e(err);\n } finally {\n _iterator2.f();\n }\n\n return result;\n }\n }]);\n\n return InputStream;\n}();\n/**\n@internal\n*/\n\n\nvar TokenGroup = /*#__PURE__*/function () {\n function TokenGroup(data, id) {\n _classCallCheck(this, TokenGroup);\n\n this.data = data;\n this.id = id;\n }\n\n _createClass(TokenGroup, [{\n key: \"token\",\n value: function token(input, stack) {\n var parser = stack.p.parser;\n readToken(this.data, input, stack, this.id, parser.data, parser.tokenPrecTable);\n }\n }]);\n\n return TokenGroup;\n}();\n\nTokenGroup.prototype.contextual = TokenGroup.prototype.fallback = TokenGroup.prototype.extend = false;\n/**\n@hide\n*/\n\nvar LocalTokenGroup = /*#__PURE__*/function () {\n function LocalTokenGroup(data, precTable, elseToken) {\n _classCallCheck(this, LocalTokenGroup);\n\n this.precTable = precTable;\n this.elseToken = elseToken;\n this.data = typeof data == \"string\" ? decodeArray(data) : data;\n }\n\n _createClass(LocalTokenGroup, [{\n key: \"token\",\n value: function token(input, stack) {\n var start = input.pos,\n skipped = 0;\n\n for (;;) {\n var atEof = input.next < 0,\n nextPos = input.resolveOffset(1, 1);\n readToken(this.data, input, stack, 0, this.data, this.precTable);\n if (input.token.value > -1) break;\n if (this.elseToken == null) return;\n if (!atEof) skipped++;\n if (nextPos == null) break;\n input.reset(nextPos, input.token);\n }\n\n if (skipped) {\n input.reset(start, input.token);\n input.acceptToken(this.elseToken, skipped);\n }\n }\n }]);\n\n return LocalTokenGroup;\n}();\n\nLocalTokenGroup.prototype.contextual = TokenGroup.prototype.fallback = TokenGroup.prototype.extend = false;\n/**\n`@external tokens` declarations in the grammar should resolve to\nan instance of this class.\n*/\n\nvar ExternalTokenizer =\n/**\nCreate a tokenizer. The first argument is the function that,\ngiven an input stream, scans for the types of tokens it\nrecognizes at the stream's position, and calls\n[`acceptToken`](#lr.InputStream.acceptToken) when it finds\none.\n*/\nfunction ExternalTokenizer(\n/**\n@internal\n*/\ntoken) {\n var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n _classCallCheck(this, ExternalTokenizer);\n\n this.token = token;\n this.contextual = !!options.contextual;\n this.fallback = !!options.fallback;\n this.extend = !!options.extend;\n}; // Tokenizer data is stored a big uint16 array containing, for each\n// state:\n//\n// - A group bitmask, indicating what token groups are reachable from\n// this state, so that paths that can only lead to tokens not in\n// any of the current groups can be cut off early.\n//\n// - The position of the end of the state's sequence of accepting\n// tokens\n//\n// - The number of outgoing edges for the state\n//\n// - The accepting tokens, as (token id, group mask) pairs\n//\n// - The outgoing edges, as (start character, end character, state\n// index) triples, with end character being exclusive\n//\n// This function interprets that data, running through a stream as\n// long as new states with the a matching group mask can be reached,\n// and updating `input.token` when it matches a token.\n\n\nfunction readToken(data, input, stack, group, precTable, precOffset) {\n var state = 0,\n groupMask = 1 << group,\n dialect = stack.p.parser.dialect;\n\n scan: for (;;) {\n if ((groupMask & data[state]) == 0) break;\n var accEnd = data[state + 1]; // Check whether this state can lead to a token in the current group\n // Accept tokens in this state, possibly overwriting\n // lower-precedence / shorter tokens\n\n for (var i = state + 3; i < accEnd; i += 2) {\n if ((data[i + 1] & groupMask) > 0) {\n var term = data[i];\n\n if (dialect.allows(term) && (input.token.value == -1 || input.token.value == term || overrides(term, input.token.value, precTable, precOffset))) {\n input.acceptToken(term);\n break;\n }\n }\n }\n\n var next = input.next,\n low = 0,\n high = data[state + 2]; // Special case for EOF\n\n if (input.next < 0 && high > low && data[accEnd + high * 3 - 3] == 65535\n /* Seq.End */\n ) {\n state = data[accEnd + high * 3 - 1];\n continue scan;\n } // Do a binary search on the state's edges\n\n\n for (; low < high;) {\n var mid = low + high >> 1;\n var index = accEnd + mid + (mid << 1);\n var from = data[index],\n to = data[index + 1] || 0x10000;\n if (next < from) high = mid;else if (next >= to) low = mid + 1;else {\n state = data[index + 2];\n input.advance();\n continue scan;\n }\n }\n\n break;\n }\n}\n\nfunction findOffset(data, start, term) {\n for (var i = start, next; (next = data[i]) != 65535\n /* Seq.End */\n ; i++) {\n if (next == term) return i - start;\n }\n\n return -1;\n}\n\nfunction overrides(token, prev, tableData, tableOffset) {\n var iPrev = findOffset(tableData, tableOffset, prev);\n return iPrev < 0 || findOffset(tableData, tableOffset, token) < iPrev;\n} // Environment variable used to control console output\n\n\nvar verbose = typeof process != \"undefined\" && process.env && /\\bparse\\b/.test(process.env.LOG);\nvar stackIDs = null;\n\nfunction cutAt(tree, pos, side) {\n var cursor = tree.cursor(IterMode.IncludeAnonymous);\n cursor.moveTo(pos);\n\n for (;;) {\n if (!(side < 0 ? cursor.childBefore(pos) : cursor.childAfter(pos))) for (;;) {\n if ((side < 0 ? cursor.to < pos : cursor.from > pos) && !cursor.type.isError) return side < 0 ? Math.max(0, Math.min(cursor.to - 1, pos - 25\n /* Safety.Margin */\n )) : Math.min(tree.length, Math.max(cursor.from + 1, pos + 25\n /* Safety.Margin */\n ));\n if (side < 0 ? cursor.prevSibling() : cursor.nextSibling()) break;\n if (!cursor.parent()) return side < 0 ? 0 : tree.length;\n }\n }\n}\n\nvar FragmentCursor = /*#__PURE__*/function () {\n function FragmentCursor(fragments, nodeSet) {\n _classCallCheck(this, FragmentCursor);\n\n this.fragments = fragments;\n this.nodeSet = nodeSet;\n this.i = 0;\n this.fragment = null;\n this.safeFrom = -1;\n this.safeTo = -1;\n this.trees = [];\n this.start = [];\n this.index = [];\n this.nextFragment();\n }\n\n _createClass(FragmentCursor, [{\n key: \"nextFragment\",\n value: function nextFragment() {\n var fr = this.fragment = this.i == this.fragments.length ? null : this.fragments[this.i++];\n\n if (fr) {\n this.safeFrom = fr.openStart ? cutAt(fr.tree, fr.from + fr.offset, 1) - fr.offset : fr.from;\n this.safeTo = fr.openEnd ? cutAt(fr.tree, fr.to + fr.offset, -1) - fr.offset : fr.to;\n\n while (this.trees.length) {\n this.trees.pop();\n this.start.pop();\n this.index.pop();\n }\n\n this.trees.push(fr.tree);\n this.start.push(-fr.offset);\n this.index.push(0);\n this.nextStart = this.safeFrom;\n } else {\n this.nextStart = 1e9;\n }\n } // `pos` must be >= any previously given `pos` for this cursor\n\n }, {\n key: \"nodeAt\",\n value: function nodeAt(pos) {\n if (pos < this.nextStart) return null;\n\n while (this.fragment && this.safeTo <= pos) {\n this.nextFragment();\n }\n\n if (!this.fragment) return null;\n\n for (;;) {\n var last = this.trees.length - 1;\n\n if (last < 0) {\n // End of tree\n this.nextFragment();\n return null;\n }\n\n var top = this.trees[last],\n index = this.index[last];\n\n if (index == top.children.length) {\n this.trees.pop();\n this.start.pop();\n this.index.pop();\n continue;\n }\n\n var next = top.children[index];\n var start = this.start[last] + top.positions[index];\n\n if (start > pos) {\n this.nextStart = start;\n return null;\n }\n\n if (next instanceof Tree) {\n if (start == pos) {\n if (start < this.safeFrom) return null;\n var end = start + next.length;\n\n if (end <= this.safeTo) {\n var lookAhead = next.prop(NodeProp.lookAhead);\n if (!lookAhead || end + lookAhead < this.fragment.to) return next;\n }\n }\n\n this.index[last]++;\n\n if (start + next.length >= Math.max(this.safeFrom, pos)) {\n // Enter this node\n this.trees.push(next);\n this.start.push(start);\n this.index.push(0);\n }\n } else {\n this.index[last]++;\n this.nextStart = start + next.length;\n }\n }\n }\n }]);\n\n return FragmentCursor;\n}();\n\nvar TokenCache = /*#__PURE__*/function () {\n function TokenCache(parser, stream) {\n _classCallCheck(this, TokenCache);\n\n this.stream = stream;\n this.tokens = [];\n this.mainToken = null;\n this.actions = [];\n this.tokens = parser.tokenizers.map(function (_) {\n return new CachedToken();\n });\n }\n\n _createClass(TokenCache, [{\n key: \"getActions\",\n value: function getActions(stack) {\n var actionIndex = 0;\n var main = null;\n var parser = stack.p.parser,\n tokenizers = parser.tokenizers;\n var mask = parser.stateSlot(stack.state, 3\n /* ParseState.TokenizerMask */\n );\n var context = stack.curContext ? stack.curContext.hash : 0;\n var lookAhead = 0;\n\n for (var i = 0; i < tokenizers.length; i++) {\n if ((1 << i & mask) == 0) continue;\n var tokenizer = tokenizers[i],\n token = this.tokens[i];\n if (main && !tokenizer.fallback) continue;\n\n if (tokenizer.contextual || token.start != stack.pos || token.mask != mask || token.context != context) {\n this.updateCachedToken(token, tokenizer, stack);\n token.mask = mask;\n token.context = context;\n }\n\n if (token.lookAhead > token.end + 25\n /* Safety.Margin */\n ) lookAhead = Math.max(token.lookAhead, lookAhead);\n\n if (token.value != 0\n /* Term.Err */\n ) {\n var startIndex = actionIndex;\n if (token.extended > -1) actionIndex = this.addActions(stack, token.extended, token.end, actionIndex);\n actionIndex = this.addActions(stack, token.value, token.end, actionIndex);\n\n if (!tokenizer.extend) {\n main = token;\n if (actionIndex > startIndex) break;\n }\n }\n }\n\n while (this.actions.length > actionIndex) {\n this.actions.pop();\n }\n\n if (lookAhead) stack.setLookAhead(lookAhead);\n\n if (!main && stack.pos == this.stream.end) {\n main = new CachedToken();\n main.value = stack.p.parser.eofTerm;\n main.start = main.end = stack.pos;\n actionIndex = this.addActions(stack, main.value, main.end, actionIndex);\n }\n\n this.mainToken = main;\n return this.actions;\n }\n }, {\n key: \"getMainToken\",\n value: function getMainToken(stack) {\n if (this.mainToken) return this.mainToken;\n var main = new CachedToken(),\n pos = stack.pos,\n p = stack.p;\n main.start = pos;\n main.end = Math.min(pos + 1, p.stream.end);\n main.value = pos == p.stream.end ? p.parser.eofTerm : 0\n /* Term.Err */\n ;\n return main;\n }\n }, {\n key: \"updateCachedToken\",\n value: function updateCachedToken(token, tokenizer, stack) {\n var start = this.stream.clipPos(stack.pos);\n tokenizer.token(this.stream.reset(start, token), stack);\n\n if (token.value > -1) {\n var parser = stack.p.parser;\n\n for (var i = 0; i < parser.specialized.length; i++) {\n if (parser.specialized[i] == token.value) {\n var result = parser.specializers[i](this.stream.read(token.start, token.end), stack);\n\n if (result >= 0 && stack.p.parser.dialect.allows(result >> 1)) {\n if ((result & 1) == 0\n /* Specialize.Specialize */\n ) token.value = result >> 1;else token.extended = result >> 1;\n break;\n }\n }\n }\n } else {\n token.value = 0\n /* Term.Err */\n ;\n token.end = this.stream.clipPos(start + 1);\n }\n }\n }, {\n key: \"putAction\",\n value: function putAction(action, token, end, index) {\n // Don't add duplicate actions\n for (var i = 0; i < index; i += 3) {\n if (this.actions[i] == action) return index;\n }\n\n this.actions[index++] = action;\n this.actions[index++] = token;\n this.actions[index++] = end;\n return index;\n }\n }, {\n key: \"addActions\",\n value: function addActions(stack, token, end, index) {\n var state = stack.state,\n parser = stack.p.parser,\n data = parser.data;\n\n for (var set = 0; set < 2; set++) {\n for (var i = parser.stateSlot(state, set ? 2\n /* ParseState.Skip */\n : 1\n /* ParseState.Actions */\n );; i += 3) {\n if (data[i] == 65535\n /* Seq.End */\n ) {\n if (data[i + 1] == 1\n /* Seq.Next */\n ) {\n i = pair(data, i + 2);\n } else {\n if (index == 0 && data[i + 1] == 2\n /* Seq.Other */\n ) index = this.putAction(pair(data, i + 2), token, end, index);\n break;\n }\n }\n\n if (data[i] == token) index = this.putAction(pair(data, i + 1), token, end, index);\n }\n }\n\n return index;\n }\n }]);\n\n return TokenCache;\n}();\n\nvar Parse = /*#__PURE__*/function () {\n function Parse(parser, input, fragments, ranges) {\n _classCallCheck(this, Parse);\n\n this.parser = parser;\n this.input = input;\n this.ranges = ranges;\n this.recovering = 0;\n this.nextStackID = 0x2654; // ♔, ♕, ♖, ♗, ♘, ♙, ♠, ♡, ♢, ♣, ♤, ♥, ♦, ♧\n\n this.minStackPos = 0;\n this.reused = [];\n this.stoppedAt = null;\n this.lastBigReductionStart = -1;\n this.lastBigReductionSize = 0;\n this.bigReductionCount = 0;\n this.stream = new InputStream(input, ranges);\n this.tokens = new TokenCache(parser, this.stream);\n this.topTerm = parser.top[1];\n var from = ranges[0].from;\n this.stacks = [Stack.start(this, parser.top[0], from)];\n this.fragments = fragments.length && this.stream.end - from > parser.bufferLength * 4 ? new FragmentCursor(fragments, parser.nodeSet) : null;\n }\n\n _createClass(Parse, [{\n key: \"parsedPos\",\n get: function get() {\n return this.minStackPos;\n } // Move the parser forward. This will process all parse stacks at\n // `this.pos` and try to advance them to a further position. If no\n // stack for such a position is found, it'll start error-recovery.\n //\n // When the parse is finished, this will return a syntax tree. When\n // not, it returns `null`.\n\n }, {\n key: \"advance\",\n value: function advance() {\n var stacks = this.stacks,\n pos = this.minStackPos; // This will hold stacks beyond `pos`.\n\n var newStacks = this.stacks = [];\n var stopped, stoppedTokens; // If a large amount of reductions happened with the same start\n // position, force the stack out of that production in order to\n // avoid creating a tree too deep to recurse through.\n // (This is an ugly kludge, because unfortunately there is no\n // straightforward, cheap way to check for this happening, due to\n // the history of reductions only being available in an\n // expensive-to-access format in the stack buffers.)\n\n if (this.bigReductionCount > 300\n /* Rec.MaxLeftAssociativeReductionCount */\n && stacks.length == 1) {\n var _stacks = _slicedToArray(stacks, 1),\n s = _stacks[0];\n\n while (s.forceReduce() && s.stack.length && s.stack[s.stack.length - 2] >= this.lastBigReductionStart) {}\n\n this.bigReductionCount = this.lastBigReductionSize = 0;\n } // Keep advancing any stacks at `pos` until they either move\n // forward or can't be advanced. Gather stacks that can't be\n // advanced further in `stopped`.\n\n\n for (var i = 0; i < stacks.length; i++) {\n var stack = stacks[i];\n\n for (;;) {\n this.tokens.mainToken = null;\n\n if (stack.pos > pos) {\n newStacks.push(stack);\n } else if (this.advanceStack(stack, newStacks, stacks)) {\n continue;\n } else {\n if (!stopped) {\n stopped = [];\n stoppedTokens = [];\n }\n\n stopped.push(stack);\n var tok = this.tokens.getMainToken(stack);\n stoppedTokens.push(tok.value, tok.end);\n }\n\n break;\n }\n }\n\n if (!newStacks.length) {\n var finished = stopped && findFinished(stopped);\n\n if (finished) {\n if (verbose) console.log(\"Finish with \" + this.stackID(finished));\n return this.stackToTree(finished);\n }\n\n if (this.parser.strict) {\n if (verbose && stopped) console.log(\"Stuck with token \" + (this.tokens.mainToken ? this.parser.getName(this.tokens.mainToken.value) : \"none\"));\n throw new SyntaxError(\"No parse at \" + pos);\n }\n\n if (!this.recovering) this.recovering = 5\n /* Rec.Distance */\n ;\n }\n\n if (this.recovering && stopped) {\n var _finished = this.stoppedAt != null && stopped[0].pos > this.stoppedAt ? stopped[0] : this.runRecovery(stopped, stoppedTokens, newStacks);\n\n if (_finished) {\n if (verbose) console.log(\"Force-finish \" + this.stackID(_finished));\n return this.stackToTree(_finished.forceAll());\n }\n }\n\n if (this.recovering) {\n var maxRemaining = this.recovering == 1 ? 1 : this.recovering * 3\n /* Rec.MaxRemainingPerStep */\n ;\n\n if (newStacks.length > maxRemaining) {\n newStacks.sort(function (a, b) {\n return b.score - a.score;\n });\n\n while (newStacks.length > maxRemaining) {\n newStacks.pop();\n }\n }\n\n if (newStacks.some(function (s) {\n return s.reducePos > pos;\n })) this.recovering--;\n } else if (newStacks.length > 1) {\n // Prune stacks that are in the same state, or that have been\n // running without splitting for a while, to avoid getting stuck\n // with multiple successful stacks running endlessly on.\n outer: for (var _i3 = 0; _i3 < newStacks.length - 1; _i3++) {\n var _stack = newStacks[_i3];\n\n for (var j = _i3 + 1; j < newStacks.length; j++) {\n var other = newStacks[j];\n\n if (_stack.sameState(other) || _stack.buffer.length > 500\n /* Rec.MinBufferLengthPrune */\n && other.buffer.length > 500\n /* Rec.MinBufferLengthPrune */\n ) {\n if ((_stack.score - other.score || _stack.buffer.length - other.buffer.length) > 0) {\n newStacks.splice(j--, 1);\n } else {\n newStacks.splice(_i3--, 1);\n continue outer;\n }\n }\n }\n }\n\n if (newStacks.length > 12\n /* Rec.MaxStackCount */\n ) newStacks.splice(12\n /* Rec.MaxStackCount */\n , newStacks.length - 12\n /* Rec.MaxStackCount */\n );\n }\n\n this.minStackPos = newStacks[0].pos;\n\n for (var _i4 = 1; _i4 < newStacks.length; _i4++) {\n if (newStacks[_i4].pos < this.minStackPos) this.minStackPos = newStacks[_i4].pos;\n }\n\n return null;\n }\n }, {\n key: \"stopAt\",\n value: function stopAt(pos) {\n if (this.stoppedAt != null && this.stoppedAt < pos) throw new RangeError(\"Can't move stoppedAt forward\");\n this.stoppedAt = pos;\n } // Returns an updated version of the given stack, or null if the\n // stack can't advance normally. When `split` and `stacks` are\n // given, stacks split off by ambiguous operations will be pushed to\n // `split`, or added to `stacks` if they move `pos` forward.\n\n }, {\n key: \"advanceStack\",\n value: function advanceStack(stack, stacks, split) {\n var start = stack.pos,\n parser = this.parser;\n var base = verbose ? this.stackID(stack) + \" -> \" : \"\";\n if (this.stoppedAt != null && start > this.stoppedAt) return stack.forceReduce() ? stack : null;\n\n if (this.fragments) {\n var strictCx = stack.curContext && stack.curContext.tracker.strict,\n cxHash = strictCx ? stack.curContext.hash : 0;\n\n for (var cached = this.fragments.nodeAt(start); cached;) {\n var match = this.parser.nodeSet.types[cached.type.id] == cached.type ? parser.getGoto(stack.state, cached.type.id) : -1;\n\n if (match > -1 && cached.length && (!strictCx || (cached.prop(NodeProp.contextHash) || 0) == cxHash)) {\n stack.useNode(cached, match);\n if (verbose) console.log(base + this.stackID(stack) + \" (via reuse of \".concat(parser.getName(cached.type.id), \")\"));\n return true;\n }\n\n if (!(cached instanceof Tree) || cached.children.length == 0 || cached.positions[0] > 0) break;\n var inner = cached.children[0];\n if (inner instanceof Tree && cached.positions[0] == 0) cached = inner;else break;\n }\n }\n\n var defaultReduce = parser.stateSlot(stack.state, 4\n /* ParseState.DefaultReduce */\n );\n\n if (defaultReduce > 0) {\n stack.reduce(defaultReduce);\n if (verbose) console.log(base + this.stackID(stack) + \" (via always-reduce \".concat(parser.getName(defaultReduce & 65535\n /* Action.ValueMask */\n ), \")\"));\n return true;\n }\n\n if (stack.stack.length >= 8400\n /* Rec.CutDepth */\n ) {\n while (stack.stack.length > 6000\n /* Rec.CutTo */\n && stack.forceReduce()) {}\n }\n\n var actions = this.tokens.getActions(stack);\n\n for (var i = 0; i < actions.length;) {\n var action = actions[i++],\n term = actions[i++],\n end = actions[i++];\n var last = i == actions.length || !split;\n var localStack = last ? stack : stack.split();\n var main = this.tokens.mainToken;\n localStack.apply(action, term, main ? main.start : localStack.pos, end);\n if (verbose) console.log(base + this.stackID(localStack) + \" (via \".concat((action & 65536\n /* Action.ReduceFlag */\n ) == 0 ? \"shift\" : \"reduce of \".concat(parser.getName(action & 65535\n /* Action.ValueMask */\n )), \" for \").concat(parser.getName(term), \" @ \").concat(start).concat(localStack == stack ? \"\" : \", split\", \")\"));\n if (last) return true;else if (localStack.pos > start) stacks.push(localStack);else split.push(localStack);\n }\n\n return false;\n } // Advance a given stack forward as far as it will go. Returns the\n // (possibly updated) stack if it got stuck, or null if it moved\n // forward and was given to `pushStackDedup`.\n\n }, {\n key: \"advanceFully\",\n value: function advanceFully(stack, newStacks) {\n var pos = stack.pos;\n\n for (;;) {\n if (!this.advanceStack(stack, null, null)) return false;\n\n if (stack.pos > pos) {\n pushStackDedup(stack, newStacks);\n return true;\n }\n }\n }\n }, {\n key: \"runRecovery\",\n value: function runRecovery(stacks, tokens, newStacks) {\n var finished = null,\n restarted = false;\n\n for (var i = 0; i < stacks.length; i++) {\n var stack = stacks[i],\n token = tokens[i << 1],\n tokenEnd = tokens[(i << 1) + 1];\n var base = verbose ? this.stackID(stack) + \" -> \" : \"\";\n\n if (stack.deadEnd) {\n if (restarted) continue;\n restarted = true;\n stack.restart();\n if (verbose) console.log(base + this.stackID(stack) + \" (restarted)\");\n var done = this.advanceFully(stack, newStacks);\n if (done) continue;\n }\n\n var force = stack.split(),\n forceBase = base;\n\n for (var j = 0; force.forceReduce() && j < 10\n /* Rec.ForceReduceLimit */\n ; j++) {\n if (verbose) console.log(forceBase + this.stackID(force) + \" (via force-reduce)\");\n\n var _done = this.advanceFully(force, newStacks);\n\n if (_done) break;\n if (verbose) forceBase = this.stackID(force) + \" -> \";\n }\n\n var _iterator3 = _createForOfIteratorHelper(stack.recoverByInsert(token)),\n _step3;\n\n try {\n for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n var insert = _step3.value;\n if (verbose) console.log(base + this.stackID(insert) + \" (via recover-insert)\");\n this.advanceFully(insert, newStacks);\n }\n } catch (err) {\n _iterator3.e(err);\n } finally {\n _iterator3.f();\n }\n\n if (this.stream.end > stack.pos) {\n if (tokenEnd == stack.pos) {\n tokenEnd++;\n token = 0\n /* Term.Err */\n ;\n }\n\n stack.recoverByDelete(token, tokenEnd);\n if (verbose) console.log(base + this.stackID(stack) + \" (via recover-delete \".concat(this.parser.getName(token), \")\"));\n pushStackDedup(stack, newStacks);\n } else if (!finished || finished.score < stack.score) {\n finished = stack;\n }\n }\n\n return finished;\n } // Convert the stack's buffer to a syntax tree.\n\n }, {\n key: \"stackToTree\",\n value: function stackToTree(stack) {\n stack.close();\n return Tree.build({\n buffer: StackBufferCursor.create(stack),\n nodeSet: this.parser.nodeSet,\n topID: this.topTerm,\n maxBufferLength: this.parser.bufferLength,\n reused: this.reused,\n start: this.ranges[0].from,\n length: stack.pos - this.ranges[0].from,\n minRepeatType: this.parser.minRepeatTerm\n });\n }\n }, {\n key: \"stackID\",\n value: function stackID(stack) {\n var id = (stackIDs || (stackIDs = new WeakMap())).get(stack);\n if (!id) stackIDs.set(stack, id = String.fromCodePoint(this.nextStackID++));\n return id + stack;\n }\n }]);\n\n return Parse;\n}();\n\nfunction pushStackDedup(stack, newStacks) {\n for (var i = 0; i < newStacks.length; i++) {\n var other = newStacks[i];\n\n if (other.pos == stack.pos && other.sameState(stack)) {\n if (newStacks[i].score < stack.score) newStacks[i] = stack;\n return;\n }\n }\n\n newStacks.push(stack);\n}\n\nvar Dialect = /*#__PURE__*/function () {\n function Dialect(source, flags, disabled) {\n _classCallCheck(this, Dialect);\n\n this.source = source;\n this.flags = flags;\n this.disabled = disabled;\n }\n\n _createClass(Dialect, [{\n key: \"allows\",\n value: function allows(term) {\n return !this.disabled || this.disabled[term] == 0;\n }\n }]);\n\n return Dialect;\n}();\n\nvar id = function id(x) {\n return x;\n};\n/**\nContext trackers are used to track stateful context (such as\nindentation in the Python grammar, or parent elements in the XML\ngrammar) needed by external tokenizers. You declare them in a\ngrammar file as `@context exportName from \"module\"`.\n\nContext values should be immutable, and can be updated (replaced)\non shift or reduce actions.\n\nThe export used in a `@context` declaration should be of this\ntype.\n*/\n\n\nvar ContextTracker =\n/**\nDefine a context tracker.\n*/\nfunction ContextTracker(spec) {\n _classCallCheck(this, ContextTracker);\n\n this.start = spec.start;\n this.shift = spec.shift || id;\n this.reduce = spec.reduce || id;\n this.reuse = spec.reuse || id;\n\n this.hash = spec.hash || function () {\n return 0;\n };\n\n this.strict = spec.strict !== false;\n};\n/**\nHolds the parse tables for a given grammar, as generated by\n`lezer-generator`, and provides [methods](#common.Parser) to parse\ncontent with.\n*/\n\n\nvar LRParser = /*#__PURE__*/function (_Parser) {\n _inherits(LRParser, _Parser);\n\n var _super = _createSuper(LRParser);\n\n /**\n @internal\n */\n function LRParser(spec) {\n var _this2$nodeSet;\n\n var _this2;\n\n _classCallCheck(this, LRParser);\n\n _this2 = _super.call(this);\n /**\n @internal\n */\n\n _this2.wrappers = [];\n if (spec.version != 14\n /* File.Version */\n ) throw new RangeError(\"Parser version (\".concat(spec.version, \") doesn't match runtime version (\", 14\n /* File.Version */\n , \")\"));\n var nodeNames = spec.nodeNames.split(\" \");\n _this2.minRepeatTerm = nodeNames.length;\n\n for (var i = 0; i < spec.repeatNodeCount; i++) {\n nodeNames.push(\"\");\n }\n\n var topTerms = Object.keys(spec.topRules).map(function (r) {\n return spec.topRules[r][1];\n });\n var nodeProps = [];\n\n for (var _i5 = 0; _i5 < nodeNames.length; _i5++) {\n nodeProps.push([]);\n }\n\n function setProp(nodeID, prop, value) {\n nodeProps[nodeID].push([prop, prop.deserialize(String(value))]);\n }\n\n if (spec.nodeProps) {\n var _iterator4 = _createForOfIteratorHelper(spec.nodeProps),\n _step4;\n\n try {\n for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {\n var propSpec = _step4.value;\n var prop = propSpec[0];\n if (typeof prop == \"string\") prop = NodeProp[prop];\n\n for (var _i6 = 1; _i6 < propSpec.length;) {\n var next = propSpec[_i6++];\n\n if (next >= 0) {\n setProp(next, prop, propSpec[_i6++]);\n } else {\n var value = propSpec[_i6 + -next];\n\n for (var j = -next; j > 0; j--) {\n setProp(propSpec[_i6++], prop, value);\n }\n\n _i6++;\n }\n }\n }\n } catch (err) {\n _iterator4.e(err);\n } finally {\n _iterator4.f();\n }\n }\n\n _this2.nodeSet = new NodeSet(nodeNames.map(function (name, i) {\n return NodeType.define({\n name: i >= _this2.minRepeatTerm ? undefined : name,\n id: i,\n props: nodeProps[i],\n top: topTerms.indexOf(i) > -1,\n error: i == 0,\n skipped: spec.skippedNodes && spec.skippedNodes.indexOf(i) > -1\n });\n }));\n if (spec.propSources) _this2.nodeSet = (_this2$nodeSet = _this2.nodeSet).extend.apply(_this2$nodeSet, _toConsumableArray(spec.propSources));\n _this2.strict = false;\n _this2.bufferLength = DefaultBufferLength;\n var tokenArray = decodeArray(spec.tokenData);\n _this2.context = spec.context;\n _this2.specializerSpecs = spec.specialized || [];\n _this2.specialized = new Uint16Array(_this2.specializerSpecs.length);\n\n for (var _i7 = 0; _i7 < _this2.specializerSpecs.length; _i7++) {\n _this2.specialized[_i7] = _this2.specializerSpecs[_i7].term;\n }\n\n _this2.specializers = _this2.specializerSpecs.map(getSpecializer);\n _this2.states = decodeArray(spec.states, Uint32Array);\n _this2.data = decodeArray(spec.stateData);\n _this2.goto = decodeArray(spec.goto);\n _this2.maxTerm = spec.maxTerm;\n _this2.tokenizers = spec.tokenizers.map(function (value) {\n return typeof value == \"number\" ? new TokenGroup(tokenArray, value) : value;\n });\n _this2.topRules = spec.topRules;\n _this2.dialects = spec.dialects || {};\n _this2.dynamicPrecedences = spec.dynamicPrecedences || null;\n _this2.tokenPrecTable = spec.tokenPrec;\n _this2.termNames = spec.termNames || null;\n _this2.maxNode = _this2.nodeSet.types.length - 1;\n _this2.dialect = _this2.parseDialect();\n _this2.top = _this2.topRules[Object.keys(_this2.topRules)[0]];\n return _this2;\n }\n\n _createClass(LRParser, [{\n key: \"createParse\",\n value: function createParse(input, fragments, ranges) {\n var parse = new Parse(this, input, fragments, ranges);\n\n var _iterator5 = _createForOfIteratorHelper(this.wrappers),\n _step5;\n\n try {\n for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {\n var w = _step5.value;\n parse = w(parse, input, fragments, ranges);\n }\n } catch (err) {\n _iterator5.e(err);\n } finally {\n _iterator5.f();\n }\n\n return parse;\n }\n /**\n Get a goto table entry @internal\n */\n\n }, {\n key: \"getGoto\",\n value: function getGoto(state, term) {\n var loose = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n var table = this.goto;\n if (term >= table[0]) return -1;\n\n for (var pos = table[term + 1];;) {\n var groupTag = table[pos++],\n last = groupTag & 1;\n var target = table[pos++];\n if (last && loose) return target;\n\n for (var end = pos + (groupTag >> 1); pos < end; pos++) {\n if (table[pos] == state) return target;\n }\n\n if (last) return -1;\n }\n }\n /**\n Check if this state has an action for a given terminal @internal\n */\n\n }, {\n key: \"hasAction\",\n value: function hasAction(state, terminal) {\n var data = this.data;\n\n for (var set = 0; set < 2; set++) {\n for (var i = this.stateSlot(state, set ? 2\n /* ParseState.Skip */\n : 1\n /* ParseState.Actions */\n ), next;; i += 3) {\n if ((next = data[i]) == 65535\n /* Seq.End */\n ) {\n if (data[i + 1] == 1\n /* Seq.Next */\n ) next = data[i = pair(data, i + 2)];else if (data[i + 1] == 2\n /* Seq.Other */\n ) return pair(data, i + 2);else break;\n }\n\n if (next == terminal || next == 0\n /* Term.Err */\n ) return pair(data, i + 1);\n }\n }\n\n return 0;\n }\n /**\n @internal\n */\n\n }, {\n key: \"stateSlot\",\n value: function stateSlot(state, slot) {\n return this.states[state * 6\n /* ParseState.Size */\n + slot];\n }\n /**\n @internal\n */\n\n }, {\n key: \"stateFlag\",\n value: function stateFlag(state, flag) {\n return (this.stateSlot(state, 0\n /* ParseState.Flags */\n ) & flag) > 0;\n }\n /**\n @internal\n */\n\n }, {\n key: \"validAction\",\n value: function validAction(state, action) {\n return !!this.allActions(state, function (a) {\n return a == action ? true : null;\n });\n }\n /**\n @internal\n */\n\n }, {\n key: \"allActions\",\n value: function allActions(state, action) {\n var deflt = this.stateSlot(state, 4\n /* ParseState.DefaultReduce */\n );\n var result = deflt ? action(deflt) : undefined;\n\n for (var i = this.stateSlot(state, 1\n /* ParseState.Actions */\n ); result == null; i += 3) {\n if (this.data[i] == 65535\n /* Seq.End */\n ) {\n if (this.data[i + 1] == 1\n /* Seq.Next */\n ) i = pair(this.data, i + 2);else break;\n }\n\n result = action(pair(this.data, i + 1));\n }\n\n return result;\n }\n /**\n Get the states that can follow this one through shift actions or\n goto jumps. @internal\n */\n\n }, {\n key: \"nextStates\",\n value: function nextStates(state) {\n var _this3 = this;\n\n var result = [];\n\n for (var i = this.stateSlot(state, 1\n /* ParseState.Actions */\n );; i += 3) {\n if (this.data[i] == 65535\n /* Seq.End */\n ) {\n if (this.data[i + 1] == 1\n /* Seq.Next */\n ) i = pair(this.data, i + 2);else break;\n }\n\n if ((this.data[i + 2] & 65536\n /* Action.ReduceFlag */\n >> 16) == 0) {\n (function () {\n var value = _this3.data[i + 1];\n if (!result.some(function (v, i) {\n return i & 1 && v == value;\n })) result.push(_this3.data[i], value);\n })();\n }\n }\n\n return result;\n }\n /**\n Configure the parser. Returns a new parser instance that has the\n given settings modified. Settings not provided in `config` are\n kept from the original parser.\n */\n\n }, {\n key: \"configure\",\n value: function configure(config) {\n var _this$nodeSet;\n\n // Hideous reflection-based kludge to make it easy to create a\n // slightly modified copy of a parser.\n var copy = Object.assign(Object.create(LRParser.prototype), this);\n if (config.props) copy.nodeSet = (_this$nodeSet = this.nodeSet).extend.apply(_this$nodeSet, _toConsumableArray(config.props));\n\n if (config.top) {\n var info = this.topRules[config.top];\n if (!info) throw new RangeError(\"Invalid top rule name \".concat(config.top));\n copy.top = info;\n }\n\n if (config.tokenizers) copy.tokenizers = this.tokenizers.map(function (t) {\n var found = config.tokenizers.find(function (r) {\n return r.from == t;\n });\n return found ? found.to : t;\n });\n\n if (config.specializers) {\n copy.specializers = this.specializers.slice();\n copy.specializerSpecs = this.specializerSpecs.map(function (s, i) {\n var found = config.specializers.find(function (r) {\n return r.from == s.external;\n });\n if (!found) return s;\n var spec = Object.assign(Object.assign({}, s), {\n external: found.to\n });\n copy.specializers[i] = getSpecializer(spec);\n return spec;\n });\n }\n\n if (config.contextTracker) copy.context = config.contextTracker;\n if (config.dialect) copy.dialect = this.parseDialect(config.dialect);\n if (config.strict != null) copy.strict = config.strict;\n if (config.wrap) copy.wrappers = copy.wrappers.concat(config.wrap);\n if (config.bufferLength != null) copy.bufferLength = config.bufferLength;\n return copy;\n }\n /**\n Tells you whether any [parse wrappers](#lr.ParserConfig.wrap)\n are registered for this parser.\n */\n\n }, {\n key: \"hasWrappers\",\n value: function hasWrappers() {\n return this.wrappers.length > 0;\n }\n /**\n Returns the name associated with a given term. This will only\n work for all terms when the parser was generated with the\n `--names` option. By default, only the names of tagged terms are\n stored.\n */\n\n }, {\n key: \"getName\",\n value: function getName(term) {\n return this.termNames ? this.termNames[term] : String(term <= this.maxNode && this.nodeSet.types[term].name || term);\n }\n /**\n The eof term id is always allocated directly after the node\n types. @internal\n */\n\n }, {\n key: \"eofTerm\",\n get: function get() {\n return this.maxNode + 1;\n }\n /**\n The type of top node produced by the parser.\n */\n\n }, {\n key: \"topNode\",\n get: function get() {\n return this.nodeSet.types[this.top[1]];\n }\n /**\n @internal\n */\n\n }, {\n key: \"dynamicPrecedence\",\n value: function dynamicPrecedence(term) {\n var prec = this.dynamicPrecedences;\n return prec == null ? 0 : prec[term] || 0;\n }\n /**\n @internal\n */\n\n }, {\n key: \"parseDialect\",\n value: function parseDialect(dialect) {\n var values = Object.keys(this.dialects),\n flags = values.map(function () {\n return false;\n });\n\n if (dialect) {\n var _iterator6 = _createForOfIteratorHelper(dialect.split(\" \")),\n _step6;\n\n try {\n for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {\n var part = _step6.value;\n\n var _id = values.indexOf(part);\n\n if (_id >= 0) flags[_id] = true;\n }\n } catch (err) {\n _iterator6.e(err);\n } finally {\n _iterator6.f();\n }\n }\n\n var disabled = null;\n\n for (var i = 0; i < values.length; i++) {\n if (!flags[i]) {\n for (var j = this.dialects[values[i]], _id2; (_id2 = this.data[j++]) != 65535\n /* Seq.End */\n ;) {\n (disabled || (disabled = new Uint8Array(this.maxTerm + 1)))[_id2] = 1;\n }\n }\n }\n\n return new Dialect(dialect, flags, disabled);\n }\n /**\n Used by the output of the parser generator. Not available to\n user code. @hide\n */\n\n }], [{\n key: \"deserialize\",\n value: function deserialize(spec) {\n return new LRParser(spec);\n }\n }]);\n\n return LRParser;\n}(Parser);\n\nfunction pair(data, off) {\n return data[off] | data[off + 1] << 16;\n}\n\nfunction findFinished(stacks) {\n var best = null;\n\n var _iterator7 = _createForOfIteratorHelper(stacks),\n _step7;\n\n try {\n for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {\n var stack = _step7.value;\n var stopped = stack.p.stoppedAt;\n if ((stack.pos == stack.p.stream.end || stopped != null && stack.pos > stopped) && stack.p.parser.stateFlag(stack.state, 2\n /* StateFlag.Accepting */\n ) && (!best || best.score < stack.score)) best = stack;\n }\n } catch (err) {\n _iterator7.e(err);\n } finally {\n _iterator7.f();\n }\n\n return best;\n}\n\nfunction getSpecializer(spec) {\n if (spec.external) {\n var mask = spec.extend ? 1\n /* Specialize.Extend */\n : 0\n /* Specialize.Specialize */\n ;\n return function (value, stack) {\n return spec.external(value, stack) << 1 | mask;\n };\n }\n\n return spec.get;\n}\n\nexport { ContextTracker, ExternalTokenizer, InputStream, LRParser, LocalTokenGroup, Stack };","function _defineProperty(obj, key, value) {\n if (key in obj) {\n Object.defineProperty(obj, key, {\n value: value,\n enumerable: true,\n configurable: true,\n writable: true\n });\n } else {\n obj[key] = value;\n }\n\n return obj;\n}\n\nmodule.exports = _defineProperty;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","var DESCRIPTORS = require('../internals/descriptors');\nvar global = require('../internals/global');\nvar isForced = require('../internals/is-forced');\nvar inheritIfRequired = require('../internals/inherit-if-required');\nvar defineProperty = require('../internals/object-define-property').f;\nvar getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar isRegExp = require('../internals/is-regexp');\nvar getFlags = require('../internals/regexp-flags');\nvar stickyHelpers = require('../internals/regexp-sticky-helpers');\nvar redefine = require('../internals/redefine');\nvar fails = require('../internals/fails');\nvar enforceInternalState = require('../internals/internal-state').enforce;\nvar setSpecies = require('../internals/set-species');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar MATCH = wellKnownSymbol('match');\nvar NativeRegExp = global.RegExp;\nvar RegExpPrototype = NativeRegExp.prototype;\nvar re1 = /a/g;\nvar re2 = /a/g;\n\n// \"new\" should create a new object, old webkit bug\nvar CORRECT_NEW = new NativeRegExp(re1) !== re1;\n\nvar UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;\n\nvar FORCED = DESCRIPTORS && isForced('RegExp', (!CORRECT_NEW || UNSUPPORTED_Y || fails(function () {\n re2[MATCH] = false;\n // RegExp constructor can alter flags and IsRegExp works correct with @@match\n return NativeRegExp(re1) != re1 || NativeRegExp(re2) == re2 || NativeRegExp(re1, 'i') != '/a/i';\n})));\n\n// `RegExp` constructor\n// https://tc39.es/ecma262/#sec-regexp-constructor\nif (FORCED) {\n var RegExpWrapper = function RegExp(pattern, flags) {\n var thisIsRegExp = this instanceof RegExpWrapper;\n var patternIsRegExp = isRegExp(pattern);\n var flagsAreUndefined = flags === undefined;\n var sticky;\n\n if (!thisIsRegExp && patternIsRegExp && pattern.constructor === RegExpWrapper && flagsAreUndefined) {\n return pattern;\n }\n\n if (CORRECT_NEW) {\n if (patternIsRegExp && !flagsAreUndefined) pattern = pattern.source;\n } else if (pattern instanceof RegExpWrapper) {\n if (flagsAreUndefined) flags = getFlags.call(pattern);\n pattern = pattern.source;\n }\n\n if (UNSUPPORTED_Y) {\n sticky = !!flags && flags.indexOf('y') > -1;\n if (sticky) flags = flags.replace(/y/g, '');\n }\n\n var result = inheritIfRequired(\n CORRECT_NEW ? new NativeRegExp(pattern, flags) : NativeRegExp(pattern, flags),\n thisIsRegExp ? this : RegExpPrototype,\n RegExpWrapper\n );\n\n if (UNSUPPORTED_Y && sticky) {\n var state = enforceInternalState(result);\n state.sticky = true;\n }\n\n return result;\n };\n var proxy = function (key) {\n key in RegExpWrapper || defineProperty(RegExpWrapper, key, {\n configurable: true,\n get: function () { return NativeRegExp[key]; },\n set: function (it) { NativeRegExp[key] = it; }\n });\n };\n var keys = getOwnPropertyNames(NativeRegExp);\n var index = 0;\n while (keys.length > index) proxy(keys[index++]);\n RegExpPrototype.constructor = RegExpWrapper;\n RegExpWrapper.prototype = RegExpPrototype;\n redefine(global, 'RegExp', RegExpWrapper);\n}\n\n// https://tc39.es/ecma262/#sec-get-regexp-@@species\nsetSpecies('RegExp');\n","var render = function render(){var _vm=this,_c=_vm._self._c;return _c('div',{staticClass:\"flex flex-col gap-2\"},[(_vm.isFormulateFormComponent)?_c('FormulateInput',{ref:\"textarea\",staticClass:\"formulate-resizable-text-area\",style:({\n height: 'auto',\n '--resizeTextAreaMinHeight': `${_vm.minHeight}rem`,\n }),attrs:{\"id\":_vm.id,\"type\":\"textarea\",\"placeholder\":_vm.placeholder,\"validation\":_vm.validation || undefined,\"validation-name\":_vm.validationName || undefined,\"validation-messages\":_vm.validationMessages,\"validation-rules\":_vm.validationRules,\"error-behavior\":_vm.errorBehavior || undefined,\"help\":_vm.help || undefined,\"maxlength\":_vm.maxLength > 0 ? _vm.maxLength : undefined,\"disabled\":_vm.isDisabled},on:{\"focus\":_vm.onFocus,\"keyup\":_vm.onKeyup,\"blur\":_vm.onBlur},model:{value:(_vm.formulateValue),callback:function ($$v) {_vm.formulateValue=$$v},expression:\"formulateValue\"}}):_c('textarea',{ref:\"textarea\",staticClass:\"transparent borderless resize-none py-2\",style:({\n minHeight: `${_vm.minHeight}rem`,\n maxHeight: `${_vm.minHeight * 2}rem`,\n }),attrs:{\"id\":_vm.id,\"placeholder\":_vm.placeholder,\"rows\":_vm.rows,\"maxlength\":_vm.maxLength > 0 ? _vm.maxLength : undefined,\"disabled\":_vm.isDisabled},domProps:{\"value\":_vm.value},on:{\"input\":_vm.onInput,\"focus\":_vm.onFocus,\"keyup\":_vm.onKeyup,\"blur\":_vm.onBlur}}),_vm._v(\" \"),(_vm.hasFooter)?_c('div',{staticClass:\"flex flex-col gap-2\"},[_vm._t(\"footer\")],2):_vm._e()],1)\n}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","import mod from \"-!../../../../node_modules/babel-loader/lib/index.js??ref--7-0!../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./ResizableTextArea.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../../../node_modules/babel-loader/lib/index.js??ref--7-0!../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./ResizableTextArea.vue?vue&type=script&lang=js&\"","\n \n
0 ? maxLength : undefined\"\n :disabled=\"isDisabled\"\n @focus=\"onFocus\"\n @keyup=\"onKeyup\"\n @blur=\"onBlur\"\n />\n\n 0 ? maxLength : undefined\"\n :disabled=\"isDisabled\"\n @input=\"onInput\"\n @focus=\"onFocus\"\n @keyup=\"onKeyup\"\n @blur=\"onBlur\"\n />\n\n \n \n
\n \n
\n\n
\n \n \n \n \n {{ button.text }}\n \n \n
\n \n\n \n {{ emptyText }}\n
\n \n