https://www.decortier.ru/_nuxt/Dnrc3094.js

139  [GUARD_REACTIVE_PROPS]: `guardReactiveProps`,
140  [TO_HANDLERS]: `toHandlers`,
141  [CAMELIZE]: `camelize`,
142  [CAPITALIZE]: `capitalize`,
143  [TO_HANDLER_KEY]: `toHandlerKey`,
144  [SET_BLOCK_TRACKING]: `setBlockTracking`,
145  [PUSH_SCOPE_ID]: `pushScopeId`,
146  [POP_SCOPE_ID]: `popScopeId`,
147  [WITH_CTX]: `withCtx`,
148  [UNREF]: `unref`,
149  [IS_REF]: `isRef`,
150  [WITH_MEMO]: `withMemo`,
151  [IS_MEMO_SAME]: `isMemoSame`
152};
153function registerRuntimeHelpers(helpers) {
154  Object.getOwnPropertySymbols(helpers).forEach((s) => {
155    helperNameMap[s] = helpers[s];
156  });
157}
158const Namespaces = {
159  "HTML": 0,
160  "0": "HTML",
161  "SVG": 1,
162  "1": "SVG",
163  "MATH_ML": 2,
164  "2": "MATH_ML"
165};
166const NodeTypes = {
167  "ROOT": 0,
168  "0": "ROOT",
169  "ELEMENT": 1,
170  "1": "ELEMENT",
171  "TEXT": 2,
172  "2": "TEXT",
173  "COMMENT": 3,
174  "3": "COMMENT",
175  "SIMPLE_EXPRESSION": 4,
176  "4": "SIMPLE_EXPRESSION",
177  "INTERPOLATION": 5,
178  "5": "INTERPOLATION",
179  "ATTRIBUTE": 6,
180  "6": "ATTRIBUTE",
181  "DIRECTIVE": 7,
182  "7": "DIRECTIVE",
183  "COMPOUND_EXPRESSION": 8,
184  "8": "COMPOUND_EXPRESSION",
185  "IF": 9,
186  "9": "IF",
187  "IF_BRANCH": 10,
188  "10": "IF_BRANCH",
189  "FOR": 11,
190  "11": "FOR",
191  "TEXT_CALL": 12,
192  "12": "TEXT_CALL",
193  "VNODE_CALL": 13,
194  "13": "VNODE_CALL",
195  "JS_CALL_EXPRESSION": 14,
196  "14": "JS_CALL_EXPRESSION",
197  "JS_OBJECT_EXPRESSION": 15,
198  "15": "JS_OBJECT_EXPRESSION",
199  "JS_PROPERTY": 16,
200  "16": "JS_PROPERTY",
201  "JS_ARRAY_EXPRESSION": 17,
202  "17": "JS_ARRAY_EXPRESSION",
203  "JS_FUNCTION_EXPRESSION": 18,
204  "18": "JS_FUNCTION_EXPRESSION",
205  "JS_CONDITIONAL_EXPRESSION": 19,
206  "19": "JS_CONDITIONAL_EXPRESSION",
207  "JS_CACHE_EXPRESSION": 20,
208  "20": "JS_CACHE_EXPRESSION",
209  "JS_BLOCK_STATEMENT": 21,
210  "21": "JS_BLOCK_STATEMENT",
211  "JS_TEMPLATE_LITERAL": 22,
212  "22": "JS_TEMPLATE_LITERAL",
213  "JS_IF_STATEMENT": 23,
214  "23": "JS_IF_STATEMENT",
215  "JS_ASSIGNMENT_EXPRESSION": 24,
216  "24": "JS_ASSIGNMENT_EXPRESSION",
217  "JS_SEQUENCE_EXPRESSION": 25,
218  "25": "JS_SEQUENCE_EXPRESSION",
219  "JS_RETURN_STATEMENT": 26,
220  "26": "JS_RETURN_STATEMENT"
221};
222const ElementTypes = {
223  "ELEMENT": 0,
224  "0": "ELEMENT",
225  "COMPONENT": 1,
226  "1": "COMPONENT",
227  "SLOT": 2,
228  "2": "SLOT",
229  "TEMPLATE": 3,
230  "3": "TEMPLATE"
231};
232const ConstantTypes = {
233  "NOT_CONSTANT": 0,
234  "0": "NOT_CONSTANT",
235  "CAN_SKIP_PATCH": 1,
236  "1": "CAN_SKIP_PATCH",
237  "CAN_CACHE": 2,
238  "2": "CAN_CACHE",
239  "CAN_STRINGIFY": 3,
240  "3": "CAN_STRINGIFY"
241};
242const locStub = {
243  start: { line: 1, column: 1, offset: 0 },
244  end: { line: 1, column: 1, offset: 0 },
245  source: ""
246};
247function createRoot(children, source = "") {
248  return {
249    type: 0,
250    source,
251    children,
252    helpers: /* @__PURE__ */ new Set(),
253    components: [],
254    directives: [],
255    hoists: [],
256    imports: [],
257    cached: [],
258    temps: 0,
259    codegenNode: void 0,
260    loc: locStub
261  };
262}
263function createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent2 = false, loc = locStub) {
264  if (context) {
265    if (isBlock) {
266      context.helper(OPEN_BLOCK);
267      context.helper(getVNodeBlockHelper(context.inSSR, isComponent2));
268    } else {
269      context.helper(getVNodeHelper(context.inSSR, isComponent2));
270    }
271    if (directives) {
272      context.helper(WITH_DIRECTIVES);
273    }
274  }
275  return {
276    type: 13,
277    tag,
278    props,
279    children,
280    patchFlag,
281    dynamicProps,
282    directives,
283    isBlock,
284    disableTracking,
285    isComponent: isComponent2,
286    loc
287  };
288}
289function createArrayExpression(elements, loc = locStub) {
290  return {
291    type: 17,
292    loc,
293    elements
294  };
295}
296function createObjectExpression(properties, loc = locStub) {
297  return {
298    type: 15,
299    loc,
300    properties
301  };
302}
303function createObjectProperty(key, value) {
304  return {
305    type: 16,
306    loc: locStub,
307    key: isString(key) ? createSimpleExpression(key, true) : key,
308    value
309  };
310}
311function createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0) {
312  return {
313    type: 4,
314    loc,
315    content,
316    isStatic,
317    constType: isStatic ? 3 : constType
318  };
319}
320function createInterpolation(content, loc) {
321  return {
322    type: 5,
323    loc,
324    content: isString(content) ? createSimpleExpression(content, false, loc) : content
325  };
326}
327function createCompoundExpression(children, loc = locStub) {
328  return {
329    type: 8,
330    loc,
331    children
332  };
333}
334function createCallExpression(callee, args = [], loc = locStub) {
335  return {
336    type: 14,
337    loc,
338    callee,
339    arguments: args
340  };
341}
342function createFunctionExpression(params, returns = void 0, newline = false, isSlot = false, loc = locStub) {
343  return {
344    type: 18,
345    params,
346    returns,
347    newline,
348    isSlot,
349    loc
350  };
351}
352function createConditionalExpression(test, consequent, alternate, newline = true) {
353  return {
354    type: 19,
355    test,
356    consequent,
357    alternate,
358    newline,
359    loc: locStub
360  };
361}
362function createCacheExpression(index, value, needPauseTracking = false, inVOnce = false) {
363  return {
364    type: 20,
365    index,
366    value,
367    needPauseTracking,
368    inVOnce,
369    needArraySpread: false,
370    loc: locStub
371  };
372}

373function createBlockStatement(body) {
374  return {
375    type: 21,
376    body,
377    loc: locStub
378  };
379}
380function createTemplateLiteral(elements) {
381  return {
382    type: 22,
383    elements,
384    loc: locStub
385  };
386}
387function createIfStatement(test, consequent, alternate) {
388  return {
389    type: 23,
390    test,
391    consequent,
392    alternate,
393    loc: locStub
394  };
395}
396function createAssignmentExpression(left, right) {
397  return {
398    type: 24,
399    left,
400    right,
401    loc: locStub
402  };
403}
404function createSequenceExpression(expressions) {
405  return {
406    type: 25,
407    expressions,
408    loc: locStub
409  };
410}
411function createReturnStatement(returns) {
412  return {
413    type: 26,
414    returns,
415    loc: locStub
416  };
417}
418function getVNodeHelper(ssr, isComponent2) {
419  return ssr || isComponent2 ? CREATE_VNODE : CREATE_ELEMENT_VNODE;
420}
421function getVNodeBlockHelper(ssr, isComponent2) {
422  return ssr || isComponent2 ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK;
423}
424function convertToBlock(node, { helper, removeHelper, inSSR }) {
425  if (!node.isBlock) {
426    node.isBlock = true;
427    removeHelper(getVNodeHelper(inSSR, node.isComponent));
428    helper(OPEN_BLOCK);
429    helper(getVNodeBlockHelper(inSSR, node.isComponent));
430  }
431}
432const defaultDelimitersOpen = new Uint8Array([123, 123]);
433const defaultDelimitersClose = new Uint8Array([125, 125]);
434function isTagStartChar(c) {
435  return c >= 97 && c <= 122 || c >= 65 && c <= 90;
436}
437function isWhitespace(c) {
438  return c === 32 || c === 10 || c === 9 || c === 12 || c === 13;
439}
440function isEndOfTagSection(c) {
441  return c === 47 || c === 62 || isWhitespace(c);
442}
443function toCharCodes(str) {
444  const ret = new Uint8Array(str.length);
445  for (let i = 0; i < str.length; i++) {
446    ret[i] = str.charCodeAt(i);
447  }
448  return ret;
449}
450const Sequences = {
451  Cdata: new Uint8Array([67, 68, 65, 84, 65, 91]),
452  // CDATA[
453  CdataEnd: new Uint8Array([93, 93, 62]),
454  // ]]>
455  CommentEnd: new Uint8Array([45, 45, 62]),
456  // `-->`
457  ScriptEnd: new Uint8Array([60, 47, 115, 99, 114, 105, 112, 116]),
458  // `<\/script`
459  StyleEnd: new Uint8Array([60, 47, 115, 116, 121, 108, 101]),
460  // `</style`
461  TitleEnd: new Uint8Array([60, 47, 116, 105, 116, 108, 101]),
462  // `</title`
463  TextareaEnd: new Uint8Array([
464    60,
465    47,
466    116,
467    101,
468    120,
469    116,
470    97,
471    114,
472    101,
473    97
474  ])
475  // `</textarea
476};
477class Tokenizer {
478  constructor(stack2, cbs) {
479    this.stack = stack2;
480    this.cbs = cbs;
481    this.state = 1;
482    this.buffer = "";
483    this.sectionStart = 0;
484    this.index = 0;
485    this.entityStart = 0;
486    this.baseState = 1;
487    this.inRCDATA = false;
488    this.inXML = false;
489    this.inVPre = false;
490    this.newlines = [];
491    this.mode = 0;
492    this.delimiterOpen = defaultDelimitersOpen;
493    this.delimiterClose = defaultDelimitersClose;
494    this.delimiterIndex = -1;
495    this.currentSequence = void 0;
496    this.sequenceIndex = 0;
497  }
498  get inSFCRoot() {
499    return this.mode === 2 && this.stack.length === 0;
500  }
501  reset() {
502    this.state = 1;
503    this.mode = 0;
504    this.buffer = "";
505    this.sectionStart = 0;
506    this.index = 0;
507    this.baseState = 1;
508    this.inRCDATA = false;
509    this.currentSequence = void 0;
510    this.newlines.length = 0;
511    this.delimiterOpen = defaultDelimitersOpen;
512    this.delimiterClose = defaultDelimitersClose;
513  }
514  /**
515   * Generate Position object with line / column information using recorded
516   * newline positions. We know the index is always going to be an already
517   * processed index, so all the newlines up to this index should have been
518   * recorded.
519   */
520  getPos(index) {
521    let line = 1;
522    let column = index + 1;
523    const length = this.newlines.length;
524    let j = -1;
525    if (length > 100) {
526      let l = -1;
527      let r = length;
528      while (l + 1 < r) {
529        const m = l + r >>> 1;
530        this.newlines[m] < index ? l = m : r = m;
531      }
532      j = l;
533    } else {
534      for (let i = length - 1; i >= 0; i--) {
535        if (index > this.newlines[i]) {
536          j = i;
537          break;
538        }
539      }
540    }
541    if (j >= 0) {
542      line = j + 2;
543      column = index - this.newlines[j];
544    }
545    return {
546      column,
547      line,
548      offset: index
549    };
550  }
551  peek() {
552    return this.buffer.charCodeAt(this.index + 1);
553  }
554  stateText(c) {
555    if (c === 60) {
556      if (this.index > this.sectionStart) {
557        this.cbs.ontext(this.sectionStart, this.index);
558      }
559      this.state = 5;
560      this.sectionStart = this.index;
561    } else if (!this.inVPre && c === this.delimiterOpen[0]) {
562      this.state = 2;
563      this.delimiterIndex = 0;
564      this.stateInterpolationOpen(c);
565    }
566  }
567  stateInterpolationOpen(c) {
568    if (c === this.delimiterOpen[this.delimiterIndex]) {
569      if (this.delimiterIndex === this.delimiterOpen.length - 1) {
570        const start = this.index + 1 - this.delimiterOpen.length;
571        if (start > this.sectionStart) {
572          this.cbs.ontext(this.sectionStart, start);
573        }
574        this.state = 3;
575        this.sectionStart = start;
576      } else {
577        this.delimiterIndex++;
578      }
579    } else if (this.inRCDATA) {
580      this.state = 32;
581      this.stateInRCDATA(c);
582    } else {
583      this.state = 1;
584      this.stateText(c);
585    }
586  }
587  stateInterpolation(c) {
588    if (c === this.delimiterClose[0]) {
589      this.state = 4;
590      this.delimiterIndex = 0;
591      this.stateInterpolationClose(c);
592    }
593  }
594  stateInterpolationClose(c) {
595    if (c === this.delimiterClose[this.delimiterIndex]) {
596      if (this.delimiterIndex === this.delimiterClose.length - 1) {
597        this.cbs.oninterpolation(this.sectionStart, this.index + 1);
598        if (this.inRCDATA) {
599          this.state = 32;
600        } else {
601          this.state = 1;
602        }
603        this.sectionStart = this.index + 1;
604      } else {
605        this.delimiterIndex++;
606      }
607    } else {
608      this.state = 3;
609      this.stateInterpolation(c);
610    }
611  }
612  stateSpecialStartSequence(c) {
613    const isEnd = this.sequenceIndex === this.currentSequence.length;
614    const isMatch = isEnd ? (
615      // If we are at the end of the sequence, make sure the tag name has ended
616      isEndOfTagSection(c)
617    ) : (
618      // Otherwise, do a case-insensitive comparison
619      (c | 32) === this.currentSequence[this.sequenceIndex]
620    );
621    if (!isMatch) {
622      this.inRCDATA = false;

623    } else if (!isEnd) {
624      this.sequenceIndex++;
625      return;
626    }
627    this.sequenceIndex = 0;
628    this.state = 6;
629    this.stateInTagName(c);
630  }
631  /** Look for an end tag. For <title> and <textarea>, also decode entities. */
632  stateInRCDATA(c) {
633    if (this.sequenceIndex === this.currentSequence.length) {
634      if (c === 62 || isWhitespace(c)) {
635        const endOfText = this.index - this.currentSequence.length;
636        if (this.sectionStart < endOfText) {
637          const actualIndex = this.index;
638          this.index = endOfText;
639          this.cbs.ontext(this.sectionStart, endOfText);
640          this.index = actualIndex;
641        }
642        this.sectionStart = endOfText + 2;
643        this.stateInClosingTagName(c);
644        this.inRCDATA = false;
645        return;
646      }
647      this.sequenceIndex = 0;
648    }
649    if ((c | 32) === this.currentSequence[this.sequenceIndex]) {
650      this.sequenceIndex += 1;
651    } else if (this.sequenceIndex === 0) {
652      if (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd && !this.inSFCRoot) {
653        if (!this.inVPre && c === this.delimiterOpen[0]) {
654          this.state = 2;
655          this.delimiterIndex = 0;
656          this.stateInterpolationOpen(c);
657        }
658      } else if (this.fastForwardTo(60)) {
659        this.sequenceIndex = 1;
660      }
661    } else {
662      this.sequenceIndex = Number(c === 60);
663    }
664  }
665  stateCDATASequence(c) {
666    if (c === Sequences.Cdata[this.sequenceIndex]) {
667      if (++this.sequenceIndex === Sequences.Cdata.length) {
668        this.state = 28;
669        this.currentSequence = Sequences.CdataEnd;
670        this.sequenceIndex = 0;
671        this.sectionStart = this.index + 1;
672      }
673    } else {
674      this.sequenceIndex = 0;
675      this.state = 23;
676      this.stateInDeclaration(c);
677    }
678  }
679  /**
680   * When we wait for one specific character, we can speed things up
681   * by skipping through the buffer until we find it.
682   *
683   * @returns Whether the character was found.
684   */
685  fastForwardTo(c) {
686    while (++this.index < this.buffer.length) {
687      const cc = this.buffer.charCodeAt(this.index);
688      if (cc === 10) {
689        this.newlines.push(this.index);
690      }
691      if (cc === c) {
692        return true;
693      }
694    }
695    this.index = this.buffer.length - 1;
696    return false;
697  }
698  /**
699   * Comments and CDATA end with `-->` and `]]>`.
700   *
701   * Their common qualities are:
702   * - Their end sequences have a distinct character they start with.
703   * - That character is then repeated, so we have to check multiple repeats.
704   * - All characters but the start character of the sequence can be skipped.
705   */
706  stateInCommentLike(c) {
707    if (c === this.currentSequence[this.sequenceIndex]) {
708      if (++this.sequenceIndex === this.currentSequence.length) {
709        if (this.currentSequence === Sequences.CdataEnd) {
710          this.cbs.oncdata(this.sectionStart, this.index - 2);
711        } else {
712          this.cbs.oncomment(this.sectionStart, this.index - 2);
713        }
714        this.sequenceIndex = 0;
715        this.sectionStart = this.index + 1;
716        this.state = 1;
717      }
718    } else if (this.sequenceIndex === 0) {
719      if (this.fastForwardTo(this.currentSequence[0])) {
720        this.sequenceIndex = 1;
721      }
722    } else if (c !== this.currentSequence[this.sequenceIndex - 1]) {
723      this.sequenceIndex = 0;
724    }
725  }
726  startSpecial(sequence, offset) {
727    this.enterRCDATA(sequence, offset);
728    this.state = 31;
729  }
730  enterRCDATA(sequence, offset) {
731    this.inRCDATA = true;
732    this.currentSequence = sequence;
733    this.sequenceIndex = offset;
734  }
735  stateBeforeTagName(c) {
736    if (c === 33) {
737      this.state = 22;
738      this.sectionStart = this.index + 1;
739    } else if (c === 63) {
740      this.state = 24;
741      this.sectionStart = this.index + 1;
742    } else if (isTagStartChar(c)) {
743      this.sectionStart = this.index;
744      if (this.mode === 0) {
745        this.state = 6;
746      } else if (this.inSFCRoot) {
747        this.state = 34;
748      } else if (!this.inXML) {
749        if (c === 116) {
750          this.state = 30;
751        } else {
752          this.state = c === 115 ? 29 : 6;
753        }
754      } else {
755        this.state = 6;
756      }
757    } else if (c === 47) {
758      this.state = 8;
759    } else {
760      this.state = 1;
761      this.stateText(c);
762    }
763  }
764  stateInTagName(c) {
765    if (isEndOfTagSection(c)) {
766      this.handleTagName(c);
767    }
768  }
769  stateInSFCRootTagName(c) {
770    if (isEndOfTagSection(c)) {
771      const tag = this.buffer.slice(this.sectionStart, this.index);
772      if (tag !== "template") {
773        this.enterRCDATA(toCharCodes(`</` + tag), 0);
774      }
775      this.handleTagName(c);
776    }
777  }
778  handleTagName(c) {
779    this.cbs.onopentagname(this.sectionStart, this.index);
780    this.sectionStart = -1;
781    this.state = 11;
782    this.stateBeforeAttrName(c);
783  }
784  stateBeforeClosingTagName(c) {
785    if (isWhitespace(c)) ;
786    else if (c === 62) {
787      this.state = 1;
788      this.sectionStart = this.index + 1;
789    } else {
790      this.state = isTagStartChar(c) ? 9 : 27;
791      this.sectionStart = this.index;
792    }
793  }
794  stateInClosingTagName(c) {
795    if (c === 62 || isWhitespace(c)) {
796      this.cbs.onclosetag(this.sectionStart, this.index);
797      this.sectionStart = -1;
798      this.state = 10;
799      this.stateAfterClosingTagName(c);
800    }
801  }
802  stateAfterClosingTagName(c) {
803    if (c === 62) {
804      this.state = 1;
805      this.sectionStart = this.index + 1;
806    }
807  }
808  stateBeforeAttrName(c) {
809    if (c === 62) {
810      this.cbs.onopentagend(this.index);
811      if (this.inRCDATA) {
812        this.state = 32;
813      } else {
814        this.state = 1;
815      }
816      this.sectionStart = this.index + 1;
817    } else if (c === 47) {
818      this.state = 7;
819    } else if (c === 60 && this.peek() === 47) {
820      this.cbs.onopentagend(this.index);
821      this.state = 5;
822      this.sectionStart = this.index;
823    } else if (!isWhitespace(c)) {
824      this.handleAttrStart(c);
825    }
826  }
827  handleAttrStart(c) {
828    if (c === 118 && this.peek() === 45) {
829      this.state = 13;
830      this.sectionStart = this.index;
831    } else if (c === 46 || c === 58 || c === 64 || c === 35) {
832      this.cbs.ondirname(this.index, this.index + 1);
833      this.state = 14;
834      this.sectionStart = this.index + 1;
835    } else {
836      this.state = 12;
837      this.sectionStart = this.index;
838    }
839  }
840  stateInSelfClosingTag(c) {
841    if (c === 62) {
842      this.cbs.onselfclosingtag(this.index);
843      this.state = 1;
844      this.sectionStart = this.index + 1;
845      this.inRCDATA = false;
846    } else if (!isWhitespace(c)) {
847      this.state = 11;
848      this.stateBeforeAttrName(c);
849    }
850  }
851  stateInAttrName(c) {
852    if (c === 61 || isEndOfTagSection(c)) {
853      this.cbs.onattribname(this.sectionStart, this.index);
854      this.handleAttrNameEnd(c);
855    }
856  }
857  stateInDirName(c) {
858    if (c === 61 || isEndOfTagSection(c)) {
859      this.cbs.ondirname(this.sectionStart, this.index);
860      this.handleAttrNameEnd(c);
861    } else if (c === 58) {
862      this.cbs.ondirname(this.sectionStart, this.index);
863      this.state = 14;
864      this.sectionStart = this.index + 1;
865    } else if (c === 46) {
866      this.cbs.ondirname(this.sectionStart, this.index);
867      this.state = 16;
868      this.sectionStart = this.index + 1;
869    }
870  }
871  stateInDirArg(c) {
872    if (c === 61 || isEndOfTagSection(c)) {
873      this.cbs.ondirarg(this.sectionStart, this.index);
874      this.handleAttrNameEnd(c);
875    } else if (c === 91) {
876      this.state = 15;
877    } else if (c === 46) {
878      this.cbs.ondirarg(this.sectionStart, this.index);
879      this.state = 16;
880      this.sectionStart = this.index + 1;
881    }
882  }
883  stateInDynamicDirArg(c) {
884    if (c === 93) {
885      this.state = 14;
886    } else if (c === 61 || isEndOfTagSection(c)) {
887      this.cbs.ondirarg(this.sectionStart, this.index + 1);
888      this.handleAttrNameEnd(c);
889    }
890  }
891  stateInDirModifier(c) {
892    if (c === 61 || isEndOfTagSection(c)) {
893      this.cbs.ondirmodifier(this.sectionStart, this.index);
894      this.handleAttrNameEnd(c);
895    } else if (c === 46) {
896      this.cbs.ondirmodifier(this.sectionStart, this.index);
897      this.sectionStart = this.index + 1;
898    }
899  }
900  handleAttrNameEnd(c) {
901    this.sectionStart = this.index;
902    this.state = 17;
903    this.cbs.onattribnameend(this.index);
904    this.stateAfterAttrName(c);
905  }
906  stateAfterAttrName(c) {
907    if (c === 61) {
908      this.state = 18;
909    } else if (c === 47 || c === 62) {
910      this.cbs.onattribend(0, this.sectionStart);
911      this.sectionStart = -1;
912      this.state = 11;
913      this.stateBeforeAttrName(c);
914    } else if (!isWhitespace(c)) {
915      this.cbs.onattribend(0, this.sectionStart);
916      this.handleAttrStart(c);
917    }
918  }
919  stateBeforeAttrValue(c) {
920    if (c === 34) {
921      this.state = 19;
922      this.sectionStart = this.index + 1;
923    } else if (c === 39) {
924      this.state = 20;
925      this.sectionStart = this.index + 1;
926    } else if (!isWhitespace(c)) {
927      this.sectionStart = this.index;
928      this.state = 21;
929      this.stateInAttrValueNoQuotes(c);
930    }
931  }
932  handleInAttrValue(c, quote) {
933    if (c === quote || this.fastForwardTo(quote)) {
934      this.cbs.onattribdata(this.sectionStart, this.index);
935      this.sectionStart = -1;
936      this.cbs.onattribend(
937        quote === 34 ? 3 : 2,
938        this.index + 1
939      );
940      this.state = 11;
941    }
942  }
943  stateInAttrValueDoubleQuotes(c) {
944    this.handleInAttrValue(c, 34);
945  }
946  stateInAttrValueSingleQuotes(c) {
947    this.handleInAttrValue(c, 39);
948  }
949  stateInAttrValueNoQuotes(c) {
950    if (isWhitespace(c) || c === 62) {
951      this.cbs.onattribdata(this.sectionStart, this.index);
952      this.sectionStart = -1;
953      this.cbs.onattribend(1, this.index);
954      this.state = 11;
955      this.stateBeforeAttrName(c);
956    } else if (c === 39 || c === 60 || c === 61 || c === 96) {
957      this.cbs.onerr(
958        18,
959        this.index
960      );
961    } else ;
962  }
963  stateBeforeDeclaration(c) {
964    if (c === 91) {
965      this.state = 26;
966      this.sequenceIndex = 0;
967    } else {
968      this.state = c === 45 ? 25 : 23;
969    }
970  }
971  stateInDeclaration(c) {
972    if (c === 62 || this.fastForwardTo(62)) {
973      this.state = 1;
974      this.sectionStart = this.index + 1;
975    }
976  }
977  stateInProcessingInstruction(c) {
978    if (c === 62 || this.fastForwardTo(62)) {
979      this.cbs.onprocessinginstruction(this.sectionStart, this.index);
980      this.state = 1;
981      this.sectionStart = this.index + 1;
982    }
983  }
984  stateBeforeComment(c) {
985    if (c === 45) {
986      this.state = 28;
987      this.currentSequence = Sequences.CommentEnd;
988      this.sequenceIndex = 2;
989      this.sectionStart = this.index + 1;
990    } else {
991      this.state = 23;
992    }
993  }
994  stateInSpecialComment(c) {
995    if (c === 62 || this.fastForwardTo(62)) {
996      this.cbs.oncomment(this.sectionStart, this.index);
997      this.state = 1;
998      this.sectionStart = this.index + 1;
999    }
1000  }
1001  stateBeforeSpecialS(c) {
1002    if (c === Sequences.ScriptEnd[3]) {
1003      this.startSpecial(Sequences.ScriptEnd, 4);
1004    } else if (c === Sequences.StyleEnd[3]) {
1005      this.startSpecial(Sequences.StyleEnd, 4);
1006    } else {
1007      this.state = 6;
1008      this.stateInTagName(c);
1009    }
1010  }
1011  stateBeforeSpecialT(c) {
1012    if (c === Sequences.TitleEnd[3]) {
1013      this.startSpecial(Sequences.TitleEnd, 4);
1014    } else if (c === Sequences.TextareaEnd[3]) {
1015      this.startSpecial(Sequences.TextareaEnd, 4);
1016    } else {
1017      this.state = 6;
1018      this.stateInTagName(c);
1019    }
1020  }
1021  startEntity() {
1022  }
1023  stateInEntity() {
1024  }
1025  /**
1026   * Iterates through the buffer, calling the function corresponding to the current state.
1027   *
1028   * States that are more likely to be hit are higher up, as a performance improvement.
1029   */
1030  parse(input) {
1031    this.buffer = input;
1032    while (this.index < this.buffer.length) {
1033      const c = this.buffer.charCodeAt(this.index);
1034      if (c === 10 && this.state !== 33) {
1035        this.newlines.push(this.index);
1036      }
1037      switch (this.state) {
1038        case 1: {
1039          this.stateText(c);
1040          break;
1041        }
1042        case 2: {
1043          this.stateInterpolationOpen(c);
1044          break;
1045        }
1046        case 3: {
1047          this.stateInterpolation(c);
1048          break;
1049        }
1050        case 4: {
1051          this.stateInterpolationClose(c);
1052          break;
1053        }
1054        case 31: {
1055          this.stateSpecialStartSequence(c);
1056          break;
1057        }
1058        case 32: {
1059          this.stateInRCDATA(c);
1060          break;
1061        }
1062        case 26: {
1063          this.stateCDATASequence(c);
1064          break;
1065        }
1066        case 19: {
1067          this.stateInAttrValueDoubleQuotes(c);
1068          break;
1069        }
1070        case 12: {
1071          this.stateInAttrName(c);
1072          break;
1073        }
1074        case 13: {
1075          this.stateInDirName(c);
1076          break;
1077        }
1078        case 14: {
1079          this.stateInDirArg(c);
1080          break;
1081        }
1082        case 15: {
1083          this.stateInDynamicDirArg(c);
1084          break;
1085        }
1086        case 16: {
1087          this.stateInDirModifier(c);
1088          break;
1089        }
1090        case 28: {
1091          this.stateInCommentLike(c);
1092          break;
1093        }
1094        case 27: {
1095          this.stateInSpecialComment(c);
1096          break;
1097        }
1098        case 11: {
1099          this.stateBeforeAttrName(c);
1100          break;
1101        }
1102        case 6: {
1103          this.stateInTagName(c);
1104          break;
1105        }
1106        case 34: {
1107          this.stateInSFCRootTagName(c);
1108          break;
1109        }
1110        case 9: {
1111          this.stateInClosingTagName(c);
1112          break;
1113        }
1114        case 5: {
1115          this.stateBeforeTagName(c);
1116          break;
1117        }
1118        case 17: {
1119          this.stateAfterAttrName(c);
1120          break;
1121        }
1122        case 20: {
1123          this.stateInAttrValueSingleQuotes(c);
1124          break;
1125        }
1126        case 18: {
1127          this.stateBeforeAttrValue(c);
1128          break;
1129        }
1130        case 8: {
1131          this.stateBeforeClosingTagName(c);
1132          break;
1133        }
1134        case 10: {
1135          this.stateAfterClosingTagName(c);
1136          break;
1137        }
1138        case 29: {
1139          this.stateBeforeSpecialS(c);
1140          break;
1141        }
1142        case 30: {
1143          this.stateBeforeSpecialT(c);
1144          break;
1145        }
1146        case 21: {
1147          this.stateInAttrValueNoQuotes(c);
1148          break;
1149        }
1150        case 7: {
1151          this.stateInSelfClosingTag(c);
1152          break;
1153        }
1154        case 23: {
1155          this.stateInDeclaration(c);
1156          break;
1157        }
1158        case 22: {
1159          this.stateBeforeDeclaration(c);
1160          break;
1161        }
1162        case 25: {
1163          this.stateBeforeComment(c);
1164          break;
1165        }
1166        case 24: {
1167          this.stateInProcessingInstruction(c);
1168          break;
1169        }
1170        case 33: {
1171          this.stateInEntity();
1172          break;
1173        }
1174      }
1175      this.index++;
1176    }
1177    this.cleanup();
1178    this.finish();
1179  }
1180  /**
1181   * Remove data that has already been consumed from the buffer.
1182   */
1183  cleanup() {
1184    if (this.sectionStart !== this.index) {
1185      if (this.state === 1 || this.state === 32 && this.sequenceIndex === 0) {
1186        this.cbs.ontext(this.sectionStart, this.index);
1187        this.sectionStart = this.index;
1188      } else if (this.state === 19 || this.state === 20 || this.state === 21) {
1189        this.cbs.onattribdata(this.sectionStart, this.index);
1190        this.sectionStart = this.index;
1191      }
1192    }
1193  }
1194  finish() {
1195    this.handleTrailingData();
1196    this.cbs.onend();
1197  }
1198  /** Handle any trailing data. */
1199  handleTrailingData() {
1200    const endIndex = this.buffer.length;
1201    if (this.sectionStart >= endIndex) {
1202      return;
1203    }
1204    if (this.state === 28) {
1205      if (this.currentSequence === Sequences.CdataEnd) {
1206        this.cbs.oncdata(this.sectionStart, endIndex);
1207      } else {
1208        this.cbs.oncomment(this.sectionStart, endIndex);
1209      }
1210    } else if (this.state === 6 || this.state === 11 || this.state === 18 || this.state === 17 || this.state === 12 || this.state === 13 || this.state === 14 || this.state === 15 || this.state === 16 || this.state === 20 || this.state === 19 || this.state === 21 || this.state === 9) ;
1211    else {
1212      this.cbs.ontext(this.sectionStart, endIndex);
1213    }
1214  }

1217
1218const CompilerDeprecationTypes = {
1219  "COMPILER_IS_ON_ELEMENT": "COMPILER_IS_ON_ELEMENT",
1220  "COMPILER_V_BIND_SYNC": "COMPILER_V_BIND_SYNC",
1221  "COMPILER_V_BIND_OBJECT_ORDER": "COMPILER_V_BIND_OBJECT_ORDER",
1222  "COMPILER_V_ON_NATIVE": "COMPILER_V_ON_NATIVE",
1223  "COMPILER_V_IF_V_FOR_PRECEDENCE": "COMPILER_V_IF_V_FOR_PRECEDENCE",
1224  "COMPILER_NATIVE_TEMPLATE": "COMPILER_NATIVE_TEMPLATE",
1225  "COMPILER_INLINE_TEMPLATE": "COMPILER_INLINE_TEMPLATE",
1226  "COMPILER_FILTERS": "COMPILER_FILTERS"
1227};
1228const deprecationData = {
1229  ["COMPILER_IS_ON_ELEMENT"]: {
1230    message: `Platform-native elements with "is" prop will no longer be treated as components in Vue 3 unless the "is" value is explicitly prefixed with "vue:".`,
1231    link: `https://v3-migration.vuejs.org/breaking-changes/custom-elements-interop.html`
1232  },
1233  ["COMPILER_V_BIND_SYNC"]: {
1234    message: (key) => `.sync modifier for v-bind has been removed. Use v-model with argument instead. \`v-bind:${key}.sync\` should be changed to \`v-model:${key}\`.`,
1235    link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html`
1236  },
1237  ["COMPILER_V_BIND_OBJECT_ORDER"]: {
1238    message: `v-bind="obj" usage is now order sensitive and behaves like JavaScript object spread: it will now overwrite an existing non-mergeable attribute that appears before v-bind in the case of conflict. To retain 2.x behavior, move v-bind to make it the first attribute. You can also suppress this warning if the usage is intended.`,
1239    link: `https://v3-migration.vuejs.org/breaking-changes/v-bind.html`
1240  },
1241  ["COMPILER_V_ON_NATIVE"]: {
1242    message: `.native modifier for v-on has been removed as is no longer necessary.`,
1243    link: `https://v3-migration.vuejs.org/breaking-changes/v-on-native-modifier-removed.html`
1244  },
1245  ["COMPILER_V_IF_V_FOR_PRECEDENCE"]: {
1246    message: `v-if / v-for precedence when used on the same element has changed in Vue 3: v-if now takes higher precedence and will no longer have access to v-for scope variables. It is best to avoid the ambiguity with <template> tags or use a computed property that filters v-for data source.`,
1247    link: `https://v3-migration.vuejs.org/breaking-changes/v-if-v-for.html`
1248  },
1249  ["COMPILER_NATIVE_TEMPLATE"]: {
1250    message: `<template> with no special directives will render as a native template element instead of its inner content in Vue 3.`
1251  },
1252  ["COMPILER_INLINE_TEMPLATE"]: {
1253    message: `"inline-template" has been removed in Vue 3.`,
1254    link: `https://v3-migration.vuejs.org/breaking-changes/inline-template-attribute.html`
1255  },
1256  ["COMPILER_FILTERS"]: {
1257    message: `filters have been removed in Vue 3. The "|" symbol will be treated as native JavaScript bitwise OR operator. Use method calls or computed properties instead.`,
1258    link: `https://v3-migration.vuejs.org/breaking-changes/filters.html`
1259  }
1260};
1261function getCompatValue(key, { compatConfig }) {
1262  const value = compatConfig && compatConfig[key];
1263  if (key === "MODE") {
1264    return value || 3;
1265  } else {
1266    return value;
1267  }
1268}
1269function isCompatEnabled(key, context) {
1270  const mode = getCompatValue("MODE", context);
1271  const value = getCompatValue(key, context);
1272  return mode === 3 ? value === true : value !== false;
1273}
1274function checkCompatEnabled(key, context, loc, ...args) {
1275  const enabled = isCompatEnabled(key, context);
1276  

1276return enabled;
1277}
1278function warnDeprecation(key, context, loc, ...args) {
1279  const val = getCompatValue(key, context);
1280  if (val === "suppress-warning") {
1281    return;
1282  }
1283  const { message, link } = deprecationData[key];
1284  const msg = `(deprecation ${key}) ${typeof message === "function" ? message(...args) : message}${link ? `
1285  Details: ${link}` : ``}`;
1286  const err = new SyntaxError(msg);
1287  err.code = key;
1288  if (loc) err.loc = loc;
1289  context.onWarn(err);
1290}
1291function defaultOnError(error) {
1292  throw error;
1293}
1294function defaultOnWarn(msg) {
1295}
1296function createCompilerError(code, loc, messages, additionalMessage) {
1297  const msg = `https://vuejs.org/error-reference/#compiler-${code}`;
1298  const error = new SyntaxError(String(msg));
1299  error.code = code;
1300  error.loc = loc;
1301  return error;
1302}
1303const ErrorCodes = {
1304  "ABRUPT_CLOSING_OF_EMPTY_COMMENT": 0,
1305  "0": "ABRUPT_CLOSING_OF_EMPTY_COMMENT",
1306  "CDATA_IN_HTML_CONTENT": 1,
1307  "1": "CDATA_IN_HTML_CONTENT",
1308  "DUPLICATE_ATTRIBUTE": 2,
1309  "2": "DUPLICATE_ATTRIBUTE",
1310  "END_TAG_WITH_ATTRIBUTES": 3,
1311  "3": "END_TAG_WITH_ATTRIBUTES",
1312  "END_TAG_WITH_TRAILING_SOLIDUS": 4,
1313  "4": "END_TAG_WITH_TRAILING_SOLIDUS",
1314  "EOF_BEFORE_TAG_NAME": 5,
1315  "5": "EOF_BEFORE_TAG_NAME",
1316  "EOF_IN_CDATA": 6,
1317  "6": "EOF_IN_CDATA",
1318  "EOF_IN_COMMENT": 7,
1319  "7": "EOF_IN_COMMENT",
1320  "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT": 8,
1321  "8": "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT",
1322  "EOF_IN_TAG": 9,
1323  "9": "EOF_IN_TAG",
1324  "INCORRECTLY_CLOSED_COMMENT": 10,
1325  "10": "INCORRECTLY_CLOSED_COMMENT",
1326  "INCORRECTLY_OPENED_COMMENT": 11,
1327  "11": "INCORRECTLY_OPENED_COMMENT",
1328  "INVALID_FIRST_CHARACTER_OF_TAG_NAME": 12,
1329  "12": "INVALID_FIRST_CHARACTER_OF_TAG_NAME",
1330  "MISSING_ATTRIBUTE_VALUE": 13,
1331  "13": "MISSING_ATTRIBUTE_VALUE",
1332  "MISSING_END_TAG_NAME": 14,
1333  "14": "MISSING_END_TAG_NAME",
1334  "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES": 15,
1335  "15": "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES",
1336  "NESTED_COMMENT": 16,
1337  "16": "NESTED_COMMENT",
1338  "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME": 17,
1339  "17": "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME",
1340  "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE": 18,
1341  "18": "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE",
1342  "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME": 19,
1343  "19": "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME",
1344  "UNEXPECTED_NULL_CHARACTER": 20,
1345  "20": "UNEXPECTED_NULL_CHARACTER",
1346  "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME": 21,
1347  "21": "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME",
1348  "UNEXPECTED_SOLIDUS_IN_TAG": 22,
1349  "22": "UNEXPECTED_SOLIDUS_IN_TAG",
1350  "X_INVALID_END_TAG": 23,
1351  "23": "X_INVALID_END_TAG",
1352  "X_MISSING_END_TAG": 24,
1353  "24": "X_MISSING_END_TAG",
1354  "X_MISSING_INTERPOLATION_END": 25,
1355  "25": "X_MISSING_INTERPOLATION_END",
1356  "X_MISSING_DIRECTIVE_NAME": 26,
1357  "26": "X_MISSING_DIRECTIVE_NAME",
1358  "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END": 27,
1359  "27": "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END",
1360  "X_V_IF_NO_EXPRESSION": 28,
1361  "28": "X_V_IF_NO_EXPRESSION",
1362  "X_V_IF_SAME_KEY": 29,
1363  "29": "X_V_IF_SAME_KEY",
1364  "X_V_ELSE_NO_ADJACENT_IF": 30,
1365  "30": "X_V_ELSE_NO_ADJACENT_IF",
1366  "X_V_FOR_NO_EXPRESSION": 31,
1367  "31": "X_V_FOR_NO_EXPRESSION",
1368  "X_V_FOR_MALFORMED_EXPRESSION": 32,
1369  "32": "X_V_FOR_MALFORMED_EXPRESSION",
1370  "X_V_FOR_TEMPLATE_KEY_PLACEMENT": 33,
1371  "33": "X_V_FOR_TEMPLATE_KEY_PLACEMENT",
1372  "X_V_BIND_NO_EXPRESSION": 34,
1373  "34": "X_V_BIND_NO_EXPRESSION",
1374  "X_V_ON_NO_EXPRESSION": 35,
1375  "35": "X_V_ON_NO_EXPRESSION",
1376  "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET": 36,
1377  "36": "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET",
1378  "X_V_SLOT_MIXED_SLOT_USAGE": 37,
1379  "37": "X_V_SLOT_MIXED_SLOT_USAGE",
1380  "X_V_SLOT_DUPLICATE_SLOT_NAMES": 38,
1381  "38": "X_V_SLOT_DUPLICATE_SLOT_NAMES",
1382  "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN": 39,
1383  "39": "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN",
1384  "X_V_SLOT_MISPLACED": 40,
1385  "40": "X_V_SLOT_MISPLACED",
1386  "X_V_MODEL_NO_EXPRESSION": 41,
1387  "41": "X_V_MODEL_NO_EXPRESSION",
1388  "X_V_MODEL_MALFORMED_EXPRESSION": 42,
1389  "42": "X_V_MODEL_MALFORMED_EXPRESSION",
1390  "X_V_MODEL_ON_SCOPE_VARIABLE": 43,
1391  "43": "X_V_MODEL_ON_SCOPE_VARIABLE",
1392  "X_V_MODEL_ON_PROPS": 44,
1393  "44": "X_V_MODEL_ON_PROPS",
1394  "X_V_MODEL_ON_CONST": 45,
1395  "45": "X_V_MODEL_ON_CONST",
1396  "X_INVALID_EXPRESSION": 46,

1486  }
1487}
1488function isInDestructureAssignment(parent, parentStack) {
1489  if (parent && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern")) {
1490    let i = parentStack.length;
1491    while (i--) {
1492      const p = parentStack[i];
1493      if (p.type === "AssignmentExpression") {
1494        return true;
1495      } else if (p.type !== "ObjectProperty" && !p.type.endsWith("Pattern")) {
1496        break;
1497      }
1498    }
1499  }
1500  return false;
1501}
1502function isInNewExpression(parentStack) {
1503  let i = parentStack.length;
1504  while (i--) {
1505    const p = parentStack[i];
1506    if (p.type === "NewExpression") {
1507      return true;
1508    } else if (p.type !== "MemberExpression") {
1509      break;
1510    }
1511  }
1512  return false;
1513}
1514function walkFunctionParams(node, onIdent) {
1515  for (const p of node.params) {
1516    for (const id of extractIdentifiers(p)) {
1517      onIdent(id);
1518    }
1519  }
1520}
1521function walkBlockDeclarations(block, onIdent) {
1522  const body = block.type === "SwitchCase" ? block.consequent : block.body;
1523  for (const stmt of body) {
1524    if (stmt.type === "VariableDeclaration") {
1525      if (stmt.declare) continue;
1526      for (const decl of stmt.declarations) {
1527        for (const id of extractIdentifiers(decl.id)) {
1528          onIdent(id);
1529        }
1530      }
1531    } else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
1532      if (stmt.declare || !stmt.id) continue;
1533      onIdent(stmt.id);
1534    } else if (isForStatement(stmt)) {
1535      walkForStatement(stmt, true, onIdent);
1536    } else if (stmt.type === "SwitchStatement") {
1537      walkSwitchStatement(stmt, true, onIdent);
1538    }
1539  }
1540}
1541function isForStatement(stmt) {
1542  return stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement";
1543}
1544function walkForStatement(stmt, isVar, onIdent) {
1545  const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left;
1546  if (variable && variable.type === "VariableDeclaration" && (variable.kind === "var" ? isVar : !isVar)) {
1547    for (const decl of variable.declarations) {
1548      for (const id of extractIdentifiers(decl.id)) {
1549        onIdent(id);
1550      }
1551    }
1552  }
1553}
1554function walkSwitchStatement(stmt, isVar, onIdent) {
1555  for (const cs of stmt.cases) {
1556    for (const stmt2 of cs.consequent) {
1557      if (stmt2.type === "VariableDeclaration" && (stmt2.kind === "var" ? isVar : !isVar)) {
1558        for (const decl of stmt2.declarations) {
1559          for (const id of extractIdentifiers(decl.id)) {
1560            onIdent(id);
1561          }
1562        }
1563      }
1564    }
1565    walkBlockDeclarations(cs, onIdent);
1566  }
1567}
1568function extractIdentifiers(param, nodes = []) {
1569  switch (param.type) {
1570    case "Identifier":
1571      nodes.push(param);
1572      break;
1573    case "MemberExpression":
1574      let object = param;
1575      while (object.type === "MemberExpression") {
1576        object = object.object;
1577      }
1578      nodes.push(object);
1579      break;
1580    case "ObjectPattern":
1581      for (const prop of param.properties) {
1582        if (prop.type === "RestElement") {
1583          extractIdentifiers(prop.argument, nodes);
1584        } else {
1585          extractIdentifiers(prop.value, nodes);
1586        }
1587      }
1588      break;
1589    case "ArrayPattern":
1590      param.elements.forEach((element) => {
1591        if (element) extractIdentifiers(element, nodes);
1592      });
1593      break;
1594    case "RestElement":
1595      extractIdentifiers(param.argument, nodes);
1596      break;
1597    case "AssignmentPattern":
1598      extractIdentifiers(param.left, nodes);
1599      break;
1600  }
1601  return nodes;
1602}
1603const isFunctionType = (node) => {
1604  return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
1605};
1606const isStaticProperty = (node) => node && (node.type === "ObjectProperty" || node.type === "ObjectMethod") && !node.computed;
1607const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
1608const TS_NODE_TYPES = [
1609  "TSAsExpression",
1610  // foo as number
1611  "TSTypeAssertion",
1612  // (<number>foo)
1613  "TSNonNullExpression",
1614  // foo!
1615  "TSInstantiationExpression",
1616  // foo<string>
1617  "TSSatisfiesExpression"
1618  // foo satisfies T
1619];
1620function unwrapTSNode(node) {
1621  if (TS_NODE_TYPES.includes(node.type)) {
1622    return unwrapTSNode(node.expression);
1623  } else {
1624    return node;
1625  }
1626}
1627const isStaticExp = (p) => p.type === 4 && p.isStatic;
1628function isCoreComponent(tag) {
1629  switch (tag) {
1630    case "Teleport":
1631    case "teleport":
1632      return TELEPORT;
1633    case "Suspense":
1634    case "suspense":
1635      return SUSPENSE;
1636    case "KeepAlive":
1637    case "keep-alive":
1638      return KEEP_ALIVE;
1639    case "BaseTransition":
1640    case "base-transition":
1641      return BASE_TRANSITION;
1642  }
1643}
1644const nonIdentifierRE = /^$|^\d|[^\$\w\xA0-\uFFFF]/;
1645const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
1646const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
1647const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/;
1648const whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g;
1649const getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source;
1650const isMemberExpressionBrowser = (exp) => {
1651  const path = getExpSource(exp).trim().replace(whitespaceRE, (s) => s.trim());
1652  let state = 0;
1653  let stateStack = [];
1654  let currentOpenBracketCount = 0;
1655  let currentOpenParensCount = 0;
1656  let currentStringType = null;
1657  for (let i = 0; i < path.length; i++) {
1658    const char = path.charAt(i);
1659    switch (state) {
1660      case 0:
1661        if (char === "[") {
1662          stateStack.push(state);
1663          state = 1;
1664          currentOpenBracketCount++;
1665        } else if (char === "(") {
1666          stateStack.push(state);
1667          state = 2;
1668          currentOpenParensCount++;
1669        } else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) {
1670          return false;
1671        }
1672        break;
1673      case 1:
1674        if (char === `'` || char === `"` || char === "`") {
1675          stateStack.push(state);
1676          state = 3;
1677          currentStringType = char;
1678        } else if (char === `[`) {
1679          currentOpenBracketCount++;
1680        } else if (char === `]`) {
1681          if (!--currentOpenBracketCount) {
1682            state = stateStack.pop();
1683          }
1684        }
1685        break;
1686      case 2:
1687        if (char === `'` || char === `"` || char === "`") {
1688          stateStack.push(state);
1689          state = 3;
1690          currentStringType = char;
1691        } else if (char === `(`) {
1692          currentOpenParensCount++;
1693        } else if (char === `)`) {
1694          if (i === path.length - 1) {
1695            return false;
1696          }
1697          if (!--currentOpenParensCount) {
1698            state = stateStack.pop();
1699          }
1700        }
1701        break;
1702      case 3:
1703        if (char === currentStringType) {
1704          state = stateStack.pop();
1705          currentStringType = null;
1706        }
1707        break;
1708    }
1709  }
1710  return !currentOpenBracketCount && !currentOpenParensCount;
1711};
1712const isMemberExpressionNode = NOOP;
1713const isMemberExpression = isMemberExpressionBrowser;
1714const fnExpRE = /^\s*(?:async\s*)?(?:\([^)]*?\)|[\w$_]+)\s*(?::[^=]+)?=>|^\s*(?:async\s+)?function(?:\s+[\w$]+)?\s*\(/;
1715const isFnExpressionBrowser = (exp) => fnExpRE.test(getExpSource(exp));
1716const isFnExpressionNode = NOOP;
1717const isFnExpression = isFnExpressionBrowser;
1718function advancePositionWithClone(pos, source, numberOfCharacters = source.length) {
1719  return advancePositionWithMutation(
1720    {
1721      offset: pos.offset,
1722      line: pos.line,
1723      column: pos.column
1724    },
1725    source,
1726    numberOfCharacters
1727  );
1728}
1729function advancePositionWithMutation(pos, source, numberOfCharacters = source.length) {
1730  let linesCount = 0;
1731  let lastNewLinePos = -1;
1732  for (let i = 0; i < numberOfCharacters; i++) {
1733    if (source.charCodeAt(i) === 10) {
1734      linesCount++;
1735      lastNewLinePos = i;
1736    }
1737  }
1738  pos.offset += numberOfCharacters;
1739  pos.line += linesCount;
1740  pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos;
1741  return pos;
1742}
1743function assert(condition, msg) {
1744  if (!condition) {
1745    throw new Error(msg || `unexpected compiler condition`);
1746  }
1747}
1748function findDir(node, name, allowEmpty = false) {
1749  for (let i = 0; i < node.props.length; i++) {
1750    const p = node.props[i];
1751    if (p.type === 7 && (allowEmpty || p.exp) && (isString(name) ? p.name === name : name.test(p.name))) {
1752      return p;
1753    }
1754  }
1755}
1756function findProp(node, name, dynamicOnly = false, allowEmpty = false) {
1757  for (let i = 0; i < node.props.length; i++) {
1758    const p = node.props[i];
1759    if (p.type === 6) {
1760      if (dynamicOnly) continue;
1761      if (p.name === name && (p.value || allowEmpty)) {
1762        return p;
1763      }
1764    } else if (p.name === "bind" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) {
1765      return p;
1766    }
1767  }
1768}
1769function isStaticArgOf(arg, name) {
1770  return !!(arg && isStaticExp(arg) && arg.content === name);
1771}
1772function hasDynamicKeyVBind(node) {
1773  return node.props.some(
1774    (p) => p.type === 7 && p.name === "bind" && (!p.arg || // v-bind="obj"
1775    p.arg.type !== 4 || // v-bind:[_ctx.foo]
1776    !p.arg.isStatic)
1777    // v-bind:[foo]
1778  );
1779}
1780function isText$1(node) {
1781  return node.type === 5 || node.type === 2;
1782}
1783function isVPre(p) {
1784  return p.type === 7 && p.name === "pre";
1785}
1786function isVSlot(p) {
1787  return p.type === 7 && p.name === "slot";
1788}
1789function isTemplateNode(node) {
1790  return node.type === 1 && node.tagType === 3;
1791}
1792function isSlotOutlet(node) {
1793  return node.type === 1 && node.tagType === 2;
1794}
1795const propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
1796function getUnnormalizedProps(props, callPath = []) {
1797  if (props && !isString(props) && props.type === 14) {
1798    const callee = props.callee;
1799    if (!isString(callee) && propsHelperSet.has(callee)) {
1800      return getUnnormalizedProps(
1801        props.arguments[0],
1802        callPath.concat(props)
1803      );
1804    }
1805  }
1806  return [props, callPath];
1807}
1808function injectProp(node, prop, context) {
1809  let propsWithInjection;
1810  let props = node.type === 13 ? node.props : node.arguments[2];
1811  let callPath = [];
1812  let parentCall;
1813  if (props && !isString(props) && props.type === 14) {
1814    const ret = getUnnormalizedProps(props);
1815    props = ret[0];
1816    callPath = ret[1];
1817    parentCall = callPath[callPath.length - 1];
1818  }
1819  if (props == null || isString(props)) {
1820    propsWithInjection = createObjectExpression([prop]);
1821  } else if (props.type === 14) {
1822    const first = props.arguments[0];
1823    if (!isString(first) && first.type === 15) {
1824      if (!hasProp(prop, first)) {
1825        first.properties.unshift(prop);
1826      }
1827    } else {
1828      if (props.callee === TO_HANDLERS) {
1829        propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
1830          createObjectExpression([prop]),
1831          props
1832        ]);
1833      } else {
1834        props.arguments.unshift(createObjectExpression([prop]));
1835      }
1836    }
1837    !propsWithInjection && (propsWithInjection = props);
1838  } else if (props.type === 15) {
1839    if (!hasProp(prop, props)) {
1840      props.properties.unshift(prop);
1841    }
1842    propsWithInjection = props;
1843  } else {
1844    propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
1845      createObjectExpression([prop]),
1846      props
1847    ]);

1848    if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) {
1849      parentCall = callPath[callPath.length - 2];
1850    }
1851  }
1852  if (node.type === 13) {
1853    if (parentCall) {
1854      parentCall.arguments[0] = propsWithInjection;
1855    } else {
1856      node.props = propsWithInjection;
1857    }
1858  } else {
1859    if (parentCall) {
1860      parentCall.arguments[0] = propsWithInjection;
1861    } else {
1862      node.arguments[2] = propsWithInjection;
1863    }
1864  }
1865}
1866function hasProp(prop, props) {
1867  let result = false;
1868  if (prop.key.type === 4) {
1869    const propKeyName = prop.key.content;
1870    result = props.properties.some(
1871      (p) => p.key.type === 4 && p.key.content === propKeyName
1872    );
1873  }
1874  return result;
1875}
1876function toValidAssetId(name, type) {
1877  return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => {
1878    return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString();
1879  })}`;
1880}
1881function hasScopeRef(node, ids) {
1882  if (!node || Object.keys(ids).length === 0) {
1883    return false;
1884  }
1885  switch (node.type) {
1886    case 1:
1887      for (let i = 0; i < node.props.length; i++) {
1888        const p = node.props[i];
1889        if (p.type === 7 && (hasScopeRef(p.arg, ids) || hasScopeRef(p.exp, ids))) {
1890          return true;
1891        }
1892      }
1893      return node.children.some((c) => hasScopeRef(c, ids));
1894    case 11:
1895      if (hasScopeRef(node.source, ids)) {
1896        return true;
1897      }
1898      return node.children.some((c) => hasScopeRef(c, ids));
1899    case 9:
1900      return node.branches.some((b) => hasScopeRef(b, ids));
1901    case 10:
1902      if (hasScopeRef(node.condition, ids)) {
1903        return true;
1904      }
1905      return node.children.some((c) => hasScopeRef(c, ids));
1906    case 4:
1907      return !node.isStatic && isSimpleIdentifier(node.content) && !!ids[node.content];
1908    case 8:
1909      return node.children.some((c) => isObject(c) && hasScopeRef(c, ids));
1910    case 5:
1911    case 12:
1912      return hasScopeRef(node.content, ids);
1913    case 2:
1914    case 3:
1915    case 20:
1916      return false;
1917    default:
1918      return false;
1919  }
1920}
1921function getMemoedVNodeCall(node) {
1922  if (node.type === 14 && node.callee === WITH_MEMO) {
1923    return node.arguments[1].returns;
1924  } else {
1925    return node;
1926  }
1927}
1928const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/;
1929function isAllWhitespace(str) {
1930  for (let i = 0; i < str.length; i++) {
1931    if (!isWhitespace(str.charCodeAt(i))) {
1932      return false;
1933    }
1934  }
1935  return true;
1936}
1937function isWhitespaceText(node) {
1938  return node.type === 2 && isAllWhitespace(node.content) || node.type === 12 && isWhitespaceText(node.content);
1939}
1940function isCommentOrWhitespace(node) {
1941  return node.type === 3 || isWhitespaceText(node);
1942}
1943const defaultParserOptions = {
1944  parseMode: "base",
1945  ns: 0,
1946  delimiters: [`{{`, `}}`],
1947  getNamespace: () => 0,
1948  isVoidTag: NO,
1949  isPreTag: NO,
1950  isIgnoreNewlineTag: NO,
1951  isCustomElement: NO,
1952  onError: defaultOnError,
1953  onWarn: defaultOnWarn,
1954  comments: false,
1955  prefixIdentifiers: false
1956};
1957let currentOptions = defaultParserOptions;
1958let currentRoot = null;
1959let currentInput = "";
1960let currentOpenTag = null;
1961let currentProp = null;
1962let currentAttrValue = "";
1963let currentAttrStartIndex = -1;
1964let currentAttrEndIndex = -1;
1965let inPre = 0;
1966let inVPre = false;
1967let currentVPreBoundary = null;
1968const stack = [];
1969const tokenizer = new Tokenizer(stack, {
1970  onerr: emitError,
1971  ontext(start, end) {
1972    onText(getSlice(start, end), start, end);
1973  },
1974  ontextentity(char, start, end) {
1975    onText(char, start, end);
1976  },
1977  oninterpolation(start, end) {
1978    if (inVPre) {
1979      return onText(getSlice(start, end), start, end);
1980    }
1981    let innerStart = start + tokenizer.delimiterOpen.length;
1982    let innerEnd = end - tokenizer.delimiterClose.length;
1983    while (isWhitespace(currentInput.charCodeAt(innerStart))) {
1984      innerStart++;
1985    }
1986    while (isWhitespace(currentInput.charCodeAt(innerEnd - 1))) {
1987      innerEnd--;
1988    }
1989    let exp = getSlice(innerStart, innerEnd);
1990    if (exp.includes("&")) {
1991      {
1992        exp = currentOptions.decodeEntities(exp, false);
1993      }
1994    }
1995    addNode({
1996      type: 5,
1997      content: createExp(exp, false, getLoc(innerStart, innerEnd)),
1998      loc: getLoc(start, end)
1999    });
2000  },
2001  onopentagname(start, end) {
2002    const name = getSlice(start, end);
2003    currentOpenTag = {
2004      type: 1,
2005      tag: name,
2006      ns: currentOptions.getNamespace(name, stack[0], currentOptions.ns),
2007      tagType: 0,
2008      // will be refined on tag close
2009      props: [],
2010      children: [],
2011      loc: getLoc(start - 1, end),
2012      codegenNode: void 0
2013    };
2014  },
2015  onopentagend(end) {

2016    endOpenTag(end);
2017  },
2018  onclosetag(start, end) {
2019    const name = getSlice(start, end);
2020    if (!currentOptions.isVoidTag(name)) {
2021      let found = false;
2022      for (let i = 0; i < stack.length; i++) {
2023        const e = stack[i];
2024        if (e.tag.toLowerCase() === name.toLowerCase()) {
2025          found = true;
2026          if (i > 0) {
2027            emitError(24, stack[0].loc.start.offset);
2028          }
2029          for (let j = 0; j <= i; j++) {
2030            const el = stack.shift();
2031            onCloseTag(el, end, j < i);
2032          }
2033          break;
2034        }
2035      }
2036      if (!found) {
2037        emitError(23, backTrack(start, 60));
2038      }
2039    }
2040  },
2041  onselfclosingtag(end) {
2042    const name = currentOpenTag.tag;
2043    currentOpenTag.isSelfClosing = true;
2044    endOpenTag(end);
2045    if (stack[0] && stack[0].tag === name) {
2046      onCloseTag(stack.shift(), end);
2047    }
2048  },
2049  onattribname(start, end) {
2050    currentProp = {
2051      type: 6,
2052      name: getSlice(start, end),
2053      nameLoc: getLoc(start, end),
2054      value: void 0,
2055      loc: getLoc(start)
2056    };
2057  },
2058  ondirname(start, end) {
2059    const raw = getSlice(start, end);
2060    const name = raw === "." || raw === ":" ? "bind" : raw === "@" ? "on" : raw === "#" ? "slot" : raw.slice(2);
2061    if (!inVPre && name === "") {
2062      emitError(26, start);
2063    }
2064    if (inVPre || name === "") {
2065      currentProp = {
2066        type: 6,
2067        name: raw,
2068        nameLoc: getLoc(start, end),
2069        value: void 0,
2070        loc: getLoc(start)
2071      };
2072    } else {
2073      currentProp = {
2074        type: 7,
2075        name,
2076        rawName: raw,
2077        exp: void 0,
2078        arg: void 0,
2079        modifiers: raw === "." ? [createSimpleExpression("prop")] : [],
2080        loc: getLoc(start)
2081      };
2082      if (name === "pre") {
2083        inVPre = tokenizer.inVPre = true;
2084        currentVPreBoundary = currentOpenTag;
2085        const props = currentOpenTag.props;
2086        for (let i = 0; i < props.length; i++) {
2087          if (props[i].type === 7) {
2088            props[i] = dirToAttr(props[i]);
2089          }
2090        }
2091      }
2092    }
2093  },
2094  ondirarg(start, end) {
2095    if (start === end) return;
2096    const arg = getSlice(start, end);
2097    if (inVPre && !isVPre(currentProp)) {
2098      currentProp.name += arg;
2099      setLocEnd(currentProp.nameLoc, end);
2100    } else {
2101      const isStatic = arg[0] !== `[`;
2102      currentProp.arg = createExp(
2103        isStatic ? arg : arg.slice(1, -1),
2104        isStatic,
2105        getLoc(start, end),
2106        isStatic ? 3 : 0
2107      );
2108    }
2109  },
2110  ondirmodifier(start, end) {
2111    const mod = getSlice(start, end);
2112    if (inVPre && !isVPre(currentProp)) {
2113      currentProp.name += "." + mod;
2114      setLocEnd(currentProp.nameLoc, end);
2115    } else if (currentProp.name === "slot") {
2116      const arg = currentProp.arg;
2117      if (arg) {
2118        arg.content += "." + mod;
2119        setLocEnd(arg.loc, end);
2120      }
2121    } else {
2122      const exp = createSimpleExpression(mod, true, getLoc(start, end));
2123      currentProp.modifiers.push(exp);
2124    }
2125  },
2126  onattribdata(start, end) {
2127    currentAttrValue += getSlice(start, end);
2128    if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
2129    currentAttrEndIndex = end;
2130  },
2131  onattribentity(char, start, end) {
2132    currentAttrValue += char;
2133    if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
2134    currentAttrEndIndex = end;
2135  },
2136  onattribnameend(end) {
2137    const start = currentProp.loc.start.offset;
2138    const name = getSlice(start, end);
2139    if (currentProp.type === 7) {
2140      currentProp.rawName = name;
2141    }
2142    if (currentOpenTag.props.some(
2143      (p) => (p.type === 7 ? p.rawName : p.name) === name
2144    )) {
2145      emitError(2, start);
2146    }
2147  },
2148  onattribend(quote, end) {
2149    if (currentOpenTag && currentProp) {
2150      setLocEnd(currentProp.loc, end);
2151      if (quote !== 0) {
2152        if (currentAttrValue.includes("&")) {
2153          currentAttrValue = currentOptions.decodeEntities(
2154            currentAttrValue,
2155            true
2156          );
2157        }
2158        if (currentProp.type === 6) {
2159          if (currentProp.name === "class") {
2160            currentAttrValue = condense(currentAttrValue).trim();
2161          }
2162          if (quote === 1 && !currentAttrValue) {
2163            emitError(13, end);
2164          }
2165          currentProp.value = {
2166            type: 2,
2167            content: currentAttrValue,
2168            loc: quote === 1 ? getLoc(currentAttrStartIndex, currentAttrEndIndex) : getLoc(currentAttrStartIndex - 1, currentAttrEndIndex + 1)
2169          };
2170          if (tokenizer.inSFCRoot && currentOpenTag.tag === "template" && currentProp.name === "lang" && currentAttrValue && currentAttrValue !== "html") {
2171            tokenizer.enterRCDATA(toCharCodes(`</template`), 0);
2172          }
2173        } else {
2174          let expParseMode = 0;
2175          currentProp.exp = createExp(
2176            currentAttrValue,
2177            false,
2178            getLoc(currentAttrStartIndex, currentAttrEndIndex),
2179            0,
2180            expParseMode
2181          );
2182          if (currentProp.name === "for") {
2183            currentProp.forParseResult = parseForExpression(currentProp.exp);
2184          }
2185          let syncIndex = -1;
2186          if (currentProp.name === "bind" && (syncIndex = currentProp.modifiers.findIndex(
2187            (mod) => mod.content === "sync"
2188          )) > -1 && checkCompatEnabled(
2189            "COMPILER_V_BIND_SYNC",
2190            currentOptions,
2191            currentProp.loc,
2192            currentProp.arg.loc.source
2193          )) {
2194            currentProp.name = "model";
2195            currentProp.modifiers.splice(syncIndex, 1);
2196          }
2197        }
2198      }
2199      if (currentProp.type !== 7 || currentProp.name !== "pre") {
2200        currentOpenTag.props.push(currentProp);
2201      }
2202    }
2203    currentAttrValue = "";
2204    currentAttrStartIndex = currentAttrEndIndex = -1;
2205  },
2206  oncomment(start, end) {
2207    if (currentOptions.comments) {
2208      addNode({
2209        type: 3,
2210        content: getSlice(start, end),
2211        loc: getLoc(start - 4, end + 3)
2212      });
2213    }
2214  },
2215  onend() {
2216    const end = currentInput.length;
2217    for (let index = 0; index < stack.length; index++) {
2218      onCloseTag(stack[index], end - 1);
2219      emitError(24, stack[index].loc.start.offset);
2220    }
2221  },
2222  oncdata(start, end) {
2223    if (stack[0].ns !== 0) {
2224      onText(getSlice(start, end), start, end);
2225    } else {
2226      emitError(1, start - 9);
2227    }
2228  },
2229  onprocessinginstruction(start) {
2230    if ((stack[0] ? stack[0].ns : currentOptions.ns) === 0) {
2231      emitError(
2232        21,
2233        start - 1
2234      );
2235    }
2236  }
2237});
2238const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
2239const stripParensRE = /^\(|\)$/g;
2240function parseForExpression(input) {
2241  const loc = input.loc;
2242  const exp = input.content;
2243  const inMatch = exp.match(forAliasRE);
2244  if (!inMatch) return;
2245  const [, LHS, RHS] = inMatch;
2246  const createAliasExpression = (content, offset, asParam = false) => {
2247    const start = loc.start.offset + offset;
2248    const end = start + content.length;
2249    return createExp(
2250      content,
2251      false,
2252      getLoc(start, end),
2253      0,
2254      asParam ? 1 : 0
2255      /* Normal */
2256    );
2257  };
2258  const result = {
2259    source: createAliasExpression(RHS.trim(), exp.indexOf(RHS, LHS.length)),
2260    value: void 0,
2261    key: void 0,
2262    index: void 0,
2263    finalized: false
2264  };
2265  let valueContent = LHS.trim().replace(stripParensRE, "").trim();
2266  const trimmedOffset = LHS.indexOf(valueContent);
2267  const iteratorMatch = valueContent.match(forIteratorRE);
2268  if (iteratorMatch) {
2269    valueContent = valueContent.replace(forIteratorRE, "").trim();
2270    const keyContent = iteratorMatch[1].trim();
2271    let keyOffset;
2272    if (keyContent) {
2273      keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);
2274      result.key = createAliasExpression(keyContent, keyOffset, true);
2275    }
2276    if (iteratorMatch[2]) {
2277      const indexContent = iteratorMatch[2].trim();
2278      if (indexContent) {
2279        result.index = createAliasExpression(
2280          indexContent,
2281          exp.indexOf(
2282            indexContent,
2283            result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length
2284          ),
2285          true
2286        );
2287      }
2288    }
2289  }
2290  if (valueContent) {
2291    result.value = createAliasExpression(valueContent, trimmedOffset, true);
2292  }
2293  return result;
2294}
2295function getSlice(start, end) {
2296  return currentInput.slice(start, end);
2297}
2298function endOpenTag(end) {
2299  if (tokenizer.inSFCRoot) {
2300    currentOpenTag.innerLoc = getLoc(end + 1, end + 1);
2301  }
2302  addNode(currentOpenTag);
2303  const { tag, ns } = currentOpenTag;
2304  if (ns === 0 && currentOptions.isPreTag(tag)) {
2305    inPre++;
2306  }
2307  if (currentOptions.isVoidTag(tag)) {
2308    onCloseTag(currentOpenTag, end);
2309  } else {
2310    stack.unshift(currentOpenTag);
2311    if (ns === 1 || ns === 2) {
2312      tokenizer.inXML = true;
2313    }
2314  }
2315  currentOpenTag = null;
2316}
2317function onText(content, start, end) {
2318  {
2319    const tag = stack[0] && stack[0].tag;
2320    if (tag !== "script" && tag !== "style" && content.includes("&")) {
2321      content = currentOptions.decodeEntities(content, false);
2322    }
2323  }
2324  const parent = stack[0] || currentRoot;
2325  const lastNode = parent.children[parent.children.length - 1];
2326  if (lastNode && lastNode.type === 2) {
2327    lastNode.content += content;
2328    setLocEnd(lastNode.loc, end);
2329  } else {
2330    parent.children.push({
2331      type: 2,
2332      content,
2333      loc: getLoc(start, end)
2334    });
2335  }
2336}
2337function onCloseTag(el, end, isImplied = false) {
2338  if (isImplied) {
2339    setLocEnd(el.loc, backTrack(end, 60));
2340  } else {
2341    setLocEnd(el.loc, lookAhead(end, 62) + 1);
2342  }
2343  if (tokenizer.inSFCRoot) {
2344    if (el.children.length) {
2345      el.innerLoc.end = extend({}, el.children[el.children.length - 1].loc.end);
2346    } else {
2347      el.innerLoc.end = extend({}, el.innerLoc.start);
2348    }
2349    el.innerLoc.source = getSlice(
2350      el.innerLoc.start.offset,
2351      el.innerLoc.end.offset
2352    );
2353  }
2354  const { tag, ns, children } = el;
2355  if (!inVPre) {
2356    if (tag === "slot") {
2357      el.tagType = 2;
2358    } else if (isFragmentTemplate(el)) {
2359      el.tagType = 3;
2360    } else if (isComponent(el)) {
2361      el.tagType = 1;
2362    }
2363  }
2364  if (!tokenizer.inRCDATA) {
2365    el.children = condenseWhitespace(children);
2366  }
2367  if (ns === 0 && currentOptions.isIgnoreNewlineTag(tag)) {
2368    const first = children[0];
2369    if (first && first.type === 2) {
2370      first.content = first.content.replace(/^\r?\n/, "");
2371    }
2372  }
2373  if (ns === 0 && currentOptions.isPreTag(tag)) {
2374    inPre--;
2375  }
2376  if (currentVPreBoundary === el) {
2377    inVPre = tokenizer.inVPre = false;
2378    currentVPreBoundary = null;
2379  }
2380  if (tokenizer.inXML && (stack[0] ? stack[0].ns : currentOptions.ns) === 0) {
2381    tokenizer.inXML = false;
2382  }
2383  {
2384    const props = el.props;
2385    if (!tokenizer.inSFCRoot && isCompatEnabled(
2386      "COMPILER_NATIVE_TEMPLATE",
2387      currentOptions
2388    ) && el.tag === "template" && !isFragmentTemplate(el)) {
2389      const parent = stack[0] || currentRoot;
2390      const index = parent.children.indexOf(el);
2391      parent.children.splice(index, 1, ...el.children);
2392    }
2393    const inlineTemplateProp = props.find(
2394      (p) => p.type === 6 && p.name === "inline-template"
2395    );
2396    if (inlineTemplateProp && checkCompatEnabled(
2397      "COMPILER_INLINE_TEMPLATE",
2398      currentOptions,
2399      inlineTemplateProp.loc
2400    ) && el.children.length) {
2401      inlineTemplateProp.value = {
2402        type: 2,
2403        content: getSlice(
2404          el.children[0].loc.start.offset,
2405          el.children[el.children.length - 1].loc.end.offset
2406        ),
2407        loc: inlineTemplateProp.loc
2408      };
2409    }
2410  }
2411}
2412function lookAhead(index, c) {
2413  let i = index;
2414  while (currentInput.charCodeAt(i) !== c && i < currentInput.length - 1) i++;
2415  return i;
2416}
2417function backTrack(index, c) {
2418  let i = index;
2419  while (currentInput.charCodeAt(i) !== c && i >= 0) i--;
2420  return i;
2421}
2422const specialTemplateDir = /* @__PURE__ */ new Set(["if", "else", "else-if", "for", "slot"]);
2423function isFragmentTemplate({ tag, props }) {
2424  if (tag === "template") {
2425    for (let i = 0; i < props.length; i++) {
2426      if (props[i].type === 7 && specialTemplateDir.has(props[i].name)) {
2427        return true;
2428      }
2429    }
2430  }
2431  return false;

2432}
2433function isComponent({ tag, props }) {
2434  if (currentOptions.isCustomElement(tag)) {
2435    return false;
2436  }
2437  if (tag === "component" || isUpperCase(tag.charCodeAt(0)) || isCoreComponent(tag) || currentOptions.isBuiltInComponent && currentOptions.isBuiltInComponent(tag) || currentOptions.isNativeTag && !currentOptions.isNativeTag(tag)) {
2438    return true;
2439  }
2440  for (let i = 0; i < props.length; i++) {
2441    const p = props[i];
2442    if (p.type === 6) {
2443      if (p.name === "is" && p.value) {
2444        if (p.value.content.startsWith("vue:")) {
2445          return true;
2446        } else if (checkCompatEnabled(
2447          "COMPILER_IS_ON_ELEMENT",
2448          currentOptions,
2449          p.loc
2450        )) {
2451          return true;
2452        }
2453      }
2454    } else if (
2455      // :is on plain element - only treat as component in compat mode
2456      p.name === "bind" && isStaticArgOf(p.arg, "is") && checkCompatEnabled(
2457        "COMPILER_IS_ON_ELEMENT",
2458        currentOptions,
2459        p.loc
2460      )
2461    ) {
2462      return true;
2463    }
2464  }
2465  return false;
2466}
2467function isUpperCase(c) {
2468  return c > 64 && c < 91;
2469}
2470const windowsNewlineRE = /\r\n/g;
2471function condenseWhitespace(nodes) {
2472  const shouldCondense = currentOptions.whitespace !== "preserve";
2473  let removedWhitespace = false;
2474  for (let i = 0; i < nodes.length; i++) {
2475    const node = nodes[i];
2476    if (node.type === 2) {
2477      if (!inPre) {
2478        if (isAllWhitespace(node.content)) {
2479          const prev = nodes[i - 1] && nodes[i - 1].type;
2480          const next = nodes[i + 1] && nodes[i + 1].type;
2481          if (!prev || !next || shouldCondense && (prev === 3 && (next === 3 || next === 1) || prev === 1 && (next === 3 || next === 1 && hasNewlineChar(node.content)))) {
2482            removedWhitespace = true;
2483            nodes[i] = null;
2484          } else {
2485            node.content = " ";
2486          }
2487        } else if (shouldCondense) {
2488          node.content = condense(node.content);
2489        }
2490      } else {
2491        node.content = node.content.replace(windowsNewlineRE, "\n");
2492      }
2493    }
2494  }
2495  return removedWhitespace ? nodes.filter(Boolean) : nodes;
2496}
2497function hasNewlineChar(str) {
2498  for (let i = 0; i < str.length; i++) {
2499    const c = str.charCodeAt(i);
2500    if (c === 10 || c === 13) {
2501      return true;
2502    }
2503  }
2504  return false;
2505}
2506function condense(str) {
2507  let ret = "";
2508  let prevCharIsWhitespace = false;
2509  for (let i = 0; i < str.length; i++) {
2510    if (isWhitespace(str.charCodeAt(i))) {
2511      if (!prevCharIsWhitespace) {
2512        ret += " ";
2513        prevCharIsWhitespace = true;
2514      }
2515    } else {
2516      ret += str[i];
2517      prevCharIsWhitespace = false;
2518    }
2519  }
2520  return ret;
2521}
2522function addNode(node) {
2523  (stack[0] || currentRoot).children.push(node);
2524}
2525function getLoc(start, end) {
2526  return {
2527    start: tokenizer.getPos(start),
2528    // @ts-expect-error allow late attachment
2529    end: end == null ? end : tokenizer.getPos(end),
2530    // @ts-expect-error allow late attachment
2531    source: end == null ? end : getSlice(start, end)
2532  };
2533}
2534function cloneLoc(loc) {
2535  return getLoc(loc.start.offset, loc.end.offset);
2536}
2537function setLocEnd(loc, end) {
2538  loc.end = tokenizer.getPos(end);
2539  loc.source = getSlice(loc.start.offset, end);
2540}
2541function dirToAttr(dir) {
2542  const attr = {
2543    type: 6,
2544    name: dir.rawName,
2545    nameLoc: getLoc(
2546      dir.loc.start.offset,
2547      dir.loc.start.offset + dir.rawName.length
2548    ),
2549    value: void 0,
2550    loc: dir.loc
2551  };
2552  if (dir.exp) {
2553    const loc = dir.exp.loc;
2554    if (loc.end.offset < dir.loc.end.offset) {
2555      loc.start.offset--;
2556      loc.start.column--;
2557      loc.end.offset++;
2558      loc.end.column++;
2559    }
2560    attr.value = {
2561      type: 2,
2562      content: dir.exp.content,
2563      loc
2564    };
2565  }
2566  return attr;
2567}
2568function createExp(content, isStatic = false, loc, constType = 0, parseMode = 0) {
2569  const exp = createSimpleExpression(content, isStatic, loc, constType);
2570  return exp;
2571}
2572function emitError(code, index, message) {
2573  currentOptions.onError(
2574    createCompilerError(code, getLoc(index, index))
2575  );
2576}
2577function reset() {
2578  tokenizer.reset();
2579  currentOpenTag = null;
2580  currentProp = null;
2581  currentAttrValue = "";

2582  currentAttrStartIndex = -1;
2583  currentAttrEndIndex = -1;
2584  stack.length = 0;
2585}
2586function baseParse(input, options) {
2587  reset();
2588  currentInput = input;
2589  currentOptions = extend({}, defaultParserOptions);
2590  if (options) {
2591    let key;
2592    for (key in options) {
2593      if (options[key] != null) {
2594        currentOptions[key] = options[key];
2595      }
2596    }
2597  }
2598  tokenizer.mode = currentOptions.parseMode === "html" ? 1 : currentOptions.parseMode === "sfc" ? 2 : 0;
2599  tokenizer.inXML = currentOptions.ns === 1 || currentOptions.ns === 2;
2600  const delimiters = options && options.delimiters;
2601  if (delimiters) {
2602    tokenizer.delimiterOpen = toCharCodes(delimiters[0]);
2603    tokenizer.delimiterClose = toCharCodes(delimiters[1]);
2604  }
2605  const root = currentRoot = createRoot([], input);
2606  tokenizer.parse(currentInput);
2607  root.loc = getLoc(0, input.length);
2608  root.children = condenseWhitespace(root.children);
2609  currentRoot = null;
2610  return root;
2611}
2612function cacheStatic(root, context) {
2613  walk(
2614    root,
2615    void 0,
2616    context,
2617    // Root node is unfortunately non-hoistable due to potential parent
2618    // fallthrough attributes.
2619    !!getSingleElementRoot(root)
2620  );
2621}
2622function getSingleElementRoot(root) {
2623  const children = root.children.filter((x) => x.type !== 3);
2624  return children.length === 1 && children[0].type === 1 && !isSlotOutlet(children[0]) ? children[0] : null;
2625}
2626function walk(node, parent, context, doNotHoistNode = false, inFor = false) {
2627  const { children } = node;
2628  const toCache = [];
2629  for (let i = 0; i < children.length; i++) {
2630    const child = children[i];
2631    if (child.type === 1 && child.tagType === 0) {
2632      const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
2633      if (constantType > 0) {
2634        if (constantType >= 2) {
2635          child.codegenNode.patchFlag = -1;
2636          toCache.push(child);
2637          continue;
2638        }
2639      } else {
2640        const codegenNode = child.codegenNode;
2641        if (codegenNode.type === 13) {
2642          const flag = codegenNode.patchFlag;
2643          if ((flag === void 0 || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) {
2644            const props = getNodeProps(child);
2645            if (props) {
2646              codegenNode.props = context.hoist(props);
2647            }
2648          }
2649          if (codegenNode.dynamicProps) {
2650            codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps);
2651          }
2652        }
2653      }
2654    } else if (child.type === 12) {
2655      const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
2656      if (constantType >= 2) {
2657        if (child.codegenNode.type === 14 && child.codegenNode.arguments.length > 0) {
2658          child.codegenNode.arguments.push(
2659            `-1`
2660          );
2661        }
2662        toCache.push(child);
2663        continue;
2664      }
2665    }
2666    if (child.type === 1) {
2667      const isComponent2 = child.tagType === 1;
2668      if (isComponent2) {
2669        context.scopes.vSlot++;
2670      }
2671      walk(child, node, context, false, inFor);
2672      if (isComponent2