source: node_modules/@vue/compiler-dom/dist/compiler-dom.cjs.prod.js@ 57e58a3

Last change on this file since 57e58a3 was 57e58a3, checked in by ste08 <sjovanoska@…>, 4 months ago

Initial commit
  • Property mode set to 100644
File size: 20.5 KB
Line 
1/**
2* @vue/compiler-dom v3.5.13
3* (c) 2018-present Yuxi (Evan) You and Vue contributors
4* @license MIT
5**/
6'use strict';
7
8Object.defineProperty(exports, '__esModule', { value: true });
9
10var compilerCore = require('@vue/compiler-core');
11var shared = require('@vue/shared');
12
13const V_MODEL_RADIO = Symbol(``);
14const V_MODEL_CHECKBOX = Symbol(
15 ``
16);
17const V_MODEL_TEXT = Symbol(``);
18const V_MODEL_SELECT = Symbol(
19 ``
20);
21const V_MODEL_DYNAMIC = Symbol(
22 ``
23);
24const V_ON_WITH_MODIFIERS = Symbol(
25 ``
26);
27const V_ON_WITH_KEYS = Symbol(
28 ``
29);
30const V_SHOW = Symbol(``);
31const TRANSITION = Symbol(``);
32const TRANSITION_GROUP = Symbol(
33 ``
34);
35compilerCore.registerRuntimeHelpers({
36 [V_MODEL_RADIO]: `vModelRadio`,
37 [V_MODEL_CHECKBOX]: `vModelCheckbox`,
38 [V_MODEL_TEXT]: `vModelText`,
39 [V_MODEL_SELECT]: `vModelSelect`,
40 [V_MODEL_DYNAMIC]: `vModelDynamic`,
41 [V_ON_WITH_MODIFIERS]: `withModifiers`,
42 [V_ON_WITH_KEYS]: `withKeys`,
43 [V_SHOW]: `vShow`,
44 [TRANSITION]: `Transition`,
45 [TRANSITION_GROUP]: `TransitionGroup`
46});
47
48const parserOptions = {
49 parseMode: "html",
50 isVoidTag: shared.isVoidTag,
51 isNativeTag: (tag) => shared.isHTMLTag(tag) || shared.isSVGTag(tag) || shared.isMathMLTag(tag),
52 isPreTag: (tag) => tag === "pre",
53 isIgnoreNewlineTag: (tag) => tag === "pre" || tag === "textarea",
54 decodeEntities: void 0,
55 isBuiltInComponent: (tag) => {
56 if (tag === "Transition" || tag === "transition") {
57 return TRANSITION;
58 } else if (tag === "TransitionGroup" || tag === "transition-group") {
59 return TRANSITION_GROUP;
60 }
61 },
62 // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
63 getNamespace(tag, parent, rootNamespace) {
64 let ns = parent ? parent.ns : rootNamespace;
65 if (parent && ns === 2) {
66 if (parent.tag === "annotation-xml") {
67 if (tag === "svg") {
68 return 1;
69 }
70 if (parent.props.some(
71 (a) => a.type === 6 && a.name === "encoding" && a.value != null && (a.value.content === "text/html" || a.value.content === "application/xhtml+xml")
72 )) {
73 ns = 0;
74 }
75 } else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== "mglyph" && tag !== "malignmark") {
76 ns = 0;
77 }
78 } else if (parent && ns === 1) {
79 if (parent.tag === "foreignObject" || parent.tag === "desc" || parent.tag === "title") {
80 ns = 0;
81 }
82 }
83 if (ns === 0) {
84 if (tag === "svg") {
85 return 1;
86 }
87 if (tag === "math") {
88 return 2;
89 }
90 }
91 return ns;
92 }
93};
94
95const transformStyle = (node) => {
96 if (node.type === 1) {
97 node.props.forEach((p, i) => {
98 if (p.type === 6 && p.name === "style" && p.value) {
99 node.props[i] = {
100 type: 7,
101 name: `bind`,
102 arg: compilerCore.createSimpleExpression(`style`, true, p.loc),
103 exp: parseInlineCSS(p.value.content, p.loc),
104 modifiers: [],
105 loc: p.loc
106 };
107 }
108 });
109 }
110};
111const parseInlineCSS = (cssText, loc) => {
112 const normalized = shared.parseStringStyle(cssText);
113 return compilerCore.createSimpleExpression(
114 JSON.stringify(normalized),
115 false,
116 loc,
117 3
118 );
119};
120
121function createDOMCompilerError(code, loc) {
122 return compilerCore.createCompilerError(
123 code,
124 loc,
125 DOMErrorMessages
126 );
127}
128const DOMErrorCodes = {
129 "X_V_HTML_NO_EXPRESSION": 53,
130 "53": "X_V_HTML_NO_EXPRESSION",
131 "X_V_HTML_WITH_CHILDREN": 54,
132 "54": "X_V_HTML_WITH_CHILDREN",
133 "X_V_TEXT_NO_EXPRESSION": 55,
134 "55": "X_V_TEXT_NO_EXPRESSION",
135 "X_V_TEXT_WITH_CHILDREN": 56,
136 "56": "X_V_TEXT_WITH_CHILDREN",
137 "X_V_MODEL_ON_INVALID_ELEMENT": 57,
138 "57": "X_V_MODEL_ON_INVALID_ELEMENT",
139 "X_V_MODEL_ARG_ON_ELEMENT": 58,
140 "58": "X_V_MODEL_ARG_ON_ELEMENT",
141 "X_V_MODEL_ON_FILE_INPUT_ELEMENT": 59,
142 "59": "X_V_MODEL_ON_FILE_INPUT_ELEMENT",
143 "X_V_MODEL_UNNECESSARY_VALUE": 60,
144 "60": "X_V_MODEL_UNNECESSARY_VALUE",
145 "X_V_SHOW_NO_EXPRESSION": 61,
146 "61": "X_V_SHOW_NO_EXPRESSION",
147 "X_TRANSITION_INVALID_CHILDREN": 62,
148 "62": "X_TRANSITION_INVALID_CHILDREN",
149 "X_IGNORED_SIDE_EFFECT_TAG": 63,
150 "63": "X_IGNORED_SIDE_EFFECT_TAG",
151 "__EXTEND_POINT__": 64,
152 "64": "__EXTEND_POINT__"
153};
154const DOMErrorMessages = {
155 [53]: `v-html is missing expression.`,
156 [54]: `v-html will override element children.`,
157 [55]: `v-text is missing expression.`,
158 [56]: `v-text will override element children.`,
159 [57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
160 [58]: `v-model argument is not supported on plain elements.`,
161 [59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
162 [60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
163 [61]: `v-show is missing expression.`,
164 [62]: `<Transition> expects exactly one child element or component.`,
165 [63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
166};
167
168const transformVHtml = (dir, node, context) => {
169 const { exp, loc } = dir;
170 if (!exp) {
171 context.onError(
172 createDOMCompilerError(53, loc)
173 );
174 }
175 if (node.children.length) {
176 context.onError(
177 createDOMCompilerError(54, loc)
178 );
179 node.children.length = 0;
180 }
181 return {
182 props: [
183 compilerCore.createObjectProperty(
184 compilerCore.createSimpleExpression(`innerHTML`, true, loc),
185 exp || compilerCore.createSimpleExpression("", true)
186 )
187 ]
188 };
189};
190
191const transformVText = (dir, node, context) => {
192 const { exp, loc } = dir;
193 if (!exp) {
194 context.onError(
195 createDOMCompilerError(55, loc)
196 );
197 }
198 if (node.children.length) {
199 context.onError(
200 createDOMCompilerError(56, loc)
201 );
202 node.children.length = 0;
203 }
204 return {
205 props: [
206 compilerCore.createObjectProperty(
207 compilerCore.createSimpleExpression(`textContent`, true),
208 exp ? compilerCore.getConstantType(exp, context) > 0 ? exp : compilerCore.createCallExpression(
209 context.helperString(compilerCore.TO_DISPLAY_STRING),
210 [exp],
211 loc
212 ) : compilerCore.createSimpleExpression("", true)
213 )
214 ]
215 };
216};
217
218const transformModel = (dir, node, context) => {
219 const baseResult = compilerCore.transformModel(dir, node, context);
220 if (!baseResult.props.length || node.tagType === 1) {
221 return baseResult;
222 }
223 if (dir.arg) {
224 context.onError(
225 createDOMCompilerError(
226 58,
227 dir.arg.loc
228 )
229 );
230 }
231 const { tag } = node;
232 const isCustomElement = context.isCustomElement(tag);
233 if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
234 let directiveToUse = V_MODEL_TEXT;
235 let isInvalidType = false;
236 if (tag === "input" || isCustomElement) {
237 const type = compilerCore.findProp(node, `type`);
238 if (type) {
239 if (type.type === 7) {
240 directiveToUse = V_MODEL_DYNAMIC;
241 } else if (type.value) {
242 switch (type.value.content) {
243 case "radio":
244 directiveToUse = V_MODEL_RADIO;
245 break;
246 case "checkbox":
247 directiveToUse = V_MODEL_CHECKBOX;
248 break;
249 case "file":
250 isInvalidType = true;
251 context.onError(
252 createDOMCompilerError(
253 59,
254 dir.loc
255 )
256 );
257 break;
258 }
259 }
260 } else if (compilerCore.hasDynamicKeyVBind(node)) {
261 directiveToUse = V_MODEL_DYNAMIC;
262 } else ;
263 } else if (tag === "select") {
264 directiveToUse = V_MODEL_SELECT;
265 } else ;
266 if (!isInvalidType) {
267 baseResult.needRuntime = context.helper(directiveToUse);
268 }
269 } else {
270 context.onError(
271 createDOMCompilerError(
272 57,
273 dir.loc
274 )
275 );
276 }
277 baseResult.props = baseResult.props.filter(
278 (p) => !(p.key.type === 4 && p.key.content === "modelValue")
279 );
280 return baseResult;
281};
282
283const isEventOptionModifier = /* @__PURE__ */ shared.makeMap(`passive,once,capture`);
284const isNonKeyModifier = /* @__PURE__ */ shared.makeMap(
285 // event propagation management
286 `stop,prevent,self,ctrl,shift,alt,meta,exact,middle`
287);
288const maybeKeyModifier = /* @__PURE__ */ shared.makeMap("left,right");
289const isKeyboardEvent = /* @__PURE__ */ shared.makeMap(`onkeyup,onkeydown,onkeypress`);
290const resolveModifiers = (key, modifiers, context, loc) => {
291 const keyModifiers = [];
292 const nonKeyModifiers = [];
293 const eventOptionModifiers = [];
294 for (let i = 0; i < modifiers.length; i++) {
295 const modifier = modifiers[i].content;
296 if (modifier === "native" && compilerCore.checkCompatEnabled(
297 "COMPILER_V_ON_NATIVE",
298 context,
299 loc
300 )) {
301 eventOptionModifiers.push(modifier);
302 } else if (isEventOptionModifier(modifier)) {
303 eventOptionModifiers.push(modifier);
304 } else {
305 if (maybeKeyModifier(modifier)) {
306 if (compilerCore.isStaticExp(key)) {
307 if (isKeyboardEvent(key.content.toLowerCase())) {
308 keyModifiers.push(modifier);
309 } else {
310 nonKeyModifiers.push(modifier);
311 }
312 } else {
313 keyModifiers.push(modifier);
314 nonKeyModifiers.push(modifier);
315 }
316 } else {
317 if (isNonKeyModifier(modifier)) {
318 nonKeyModifiers.push(modifier);
319 } else {
320 keyModifiers.push(modifier);
321 }
322 }
323 }
324 }
325 return {
326 keyModifiers,
327 nonKeyModifiers,
328 eventOptionModifiers
329 };
330};
331const transformClick = (key, event) => {
332 const isStaticClick = compilerCore.isStaticExp(key) && key.content.toLowerCase() === "onclick";
333 return isStaticClick ? compilerCore.createSimpleExpression(event, true) : key.type !== 4 ? compilerCore.createCompoundExpression([
334 `(`,
335 key,
336 `) === "onClick" ? "${event}" : (`,
337 key,
338 `)`
339 ]) : key;
340};
341const transformOn = (dir, node, context) => {
342 return compilerCore.transformOn(dir, node, context, (baseResult) => {
343 const { modifiers } = dir;
344 if (!modifiers.length) return baseResult;
345 let { key, value: handlerExp } = baseResult.props[0];
346 const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);
347 if (nonKeyModifiers.includes("right")) {
348 key = transformClick(key, `onContextmenu`);
349 }
350 if (nonKeyModifiers.includes("middle")) {
351 key = transformClick(key, `onMouseup`);
352 }
353 if (nonKeyModifiers.length) {
354 handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [
355 handlerExp,
356 JSON.stringify(nonKeyModifiers)
357 ]);
358 }
359 if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard
360 (!compilerCore.isStaticExp(key) || isKeyboardEvent(key.content.toLowerCase()))) {
361 handlerExp = compilerCore.createCallExpression(context.helper(V_ON_WITH_KEYS), [
362 handlerExp,
363 JSON.stringify(keyModifiers)
364 ]);
365 }
366 if (eventOptionModifiers.length) {
367 const modifierPostfix = eventOptionModifiers.map(shared.capitalize).join("");
368 key = compilerCore.isStaticExp(key) ? compilerCore.createSimpleExpression(`${key.content}${modifierPostfix}`, true) : compilerCore.createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]);
369 }
370 return {
371 props: [compilerCore.createObjectProperty(key, handlerExp)]
372 };
373 });
374};
375
376const transformShow = (dir, node, context) => {
377 const { exp, loc } = dir;
378 if (!exp) {
379 context.onError(
380 createDOMCompilerError(61, loc)
381 );
382 }
383 return {
384 props: [],
385 needRuntime: context.helper(V_SHOW)
386 };
387};
388
389const expReplaceRE = /__VUE_EXP_START__(.*?)__VUE_EXP_END__/g;
390const stringifyStatic = (children, context, parent) => {
391 if (context.scopes.vSlot > 0) {
392 return;
393 }
394 const isParentCached = parent.type === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !shared.isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 20;
395 let nc = 0;
396 let ec = 0;
397 const currentChunk = [];
398 const stringifyCurrentChunk = (currentIndex) => {
399 if (nc >= 20 || ec >= 5) {
400 const staticCall = compilerCore.createCallExpression(context.helper(compilerCore.CREATE_STATIC), [
401 JSON.stringify(
402 currentChunk.map((node) => stringifyNode(node, context)).join("")
403 ).replace(expReplaceRE, `" + $1 + "`),
404 // the 2nd argument indicates the number of DOM nodes this static vnode
405 // will insert / hydrate
406 String(currentChunk.length)
407 ]);
408 const deleteCount = currentChunk.length - 1;
409 if (isParentCached) {
410 children.splice(
411 currentIndex - currentChunk.length,
412 currentChunk.length,
413 // @ts-expect-error
414 staticCall
415 );
416 } else {
417 currentChunk[0].codegenNode.value = staticCall;
418 if (currentChunk.length > 1) {
419 children.splice(currentIndex - currentChunk.length + 1, deleteCount);
420 const cacheIndex = context.cached.indexOf(
421 currentChunk[currentChunk.length - 1].codegenNode
422 );
423 if (cacheIndex > -1) {
424 for (let i2 = cacheIndex; i2 < context.cached.length; i2++) {
425 const c = context.cached[i2];
426 if (c) c.index -= deleteCount;
427 }
428 context.cached.splice(cacheIndex - deleteCount + 1, deleteCount);
429 }
430 }
431 }
432 return deleteCount;
433 }
434 return 0;
435 };
436 let i = 0;
437 for (; i < children.length; i++) {
438 const child = children[i];
439 const isCached = isParentCached || getCachedNode(child);
440 if (isCached) {
441 const result = analyzeNode(child);
442 if (result) {
443 nc += result[0];
444 ec += result[1];
445 currentChunk.push(child);
446 continue;
447 }
448 }
449 i -= stringifyCurrentChunk(i);
450 nc = 0;
451 ec = 0;
452 currentChunk.length = 0;
453 }
454 stringifyCurrentChunk(i);
455};
456const getCachedNode = (node) => {
457 if ((node.type === 1 && node.tagType === 0 || node.type === 12) && node.codegenNode && node.codegenNode.type === 20) {
458 return node.codegenNode;
459 }
460};
461const dataAriaRE = /^(data|aria)-/;
462const isStringifiableAttr = (name, ns) => {
463 return (ns === 0 ? shared.isKnownHtmlAttr(name) : ns === 1 ? shared.isKnownSvgAttr(name) : ns === 2 ? shared.isKnownMathMLAttr(name) : false) || dataAriaRE.test(name);
464};
465const isNonStringifiable = /* @__PURE__ */ shared.makeMap(
466 `caption,thead,tr,th,tbody,td,tfoot,colgroup,col`
467);
468function analyzeNode(node) {
469 if (node.type === 1 && isNonStringifiable(node.tag)) {
470 return false;
471 }
472 if (node.type === 12) {
473 return [1, 0];
474 }
475 let nc = 1;
476 let ec = node.props.length > 0 ? 1 : 0;
477 let bailed = false;
478 const bail = () => {
479 bailed = true;
480 return false;
481 };
482 function walk(node2) {
483 const isOptionTag = node2.tag === "option" && node2.ns === 0;
484 for (let i = 0; i < node2.props.length; i++) {
485 const p = node2.props[i];
486 if (p.type === 6 && !isStringifiableAttr(p.name, node2.ns)) {
487 return bail();
488 }
489 if (p.type === 7 && p.name === "bind") {
490 if (p.arg && (p.arg.type === 8 || p.arg.isStatic && !isStringifiableAttr(p.arg.content, node2.ns))) {
491 return bail();
492 }
493 if (p.exp && (p.exp.type === 8 || p.exp.constType < 3)) {
494 return bail();
495 }
496 if (isOptionTag && compilerCore.isStaticArgOf(p.arg, "value") && p.exp && !p.exp.isStatic) {
497 return bail();
498 }
499 }
500 }
501 for (let i = 0; i < node2.children.length; i++) {
502 nc++;
503 const child = node2.children[i];
504 if (child.type === 1) {
505 if (child.props.length > 0) {
506 ec++;
507 }
508 walk(child);
509 if (bailed) {
510 return false;
511 }
512 }
513 }
514 return true;
515 }
516 return walk(node) ? [nc, ec] : false;
517}
518function stringifyNode(node, context) {
519 if (shared.isString(node)) {
520 return node;
521 }
522 if (shared.isSymbol(node)) {
523 return ``;
524 }
525 switch (node.type) {
526 case 1:
527 return stringifyElement(node, context);
528 case 2:
529 return shared.escapeHtml(node.content);
530 case 3:
531 return `<!--${shared.escapeHtml(node.content)}-->`;
532 case 5:
533 return shared.escapeHtml(shared.toDisplayString(evaluateConstant(node.content)));
534 case 8:
535 return shared.escapeHtml(evaluateConstant(node));
536 case 12:
537 return stringifyNode(node.content, context);
538 default:
539 return "";
540 }
541}
542function stringifyElement(node, context) {
543 let res = `<${node.tag}`;
544 let innerHTML = "";
545 for (let i = 0; i < node.props.length; i++) {
546 const p = node.props[i];
547 if (p.type === 6) {
548 res += ` ${p.name}`;
549 if (p.value) {
550 res += `="${shared.escapeHtml(p.value.content)}"`;
551 }
552 } else if (p.type === 7) {
553 if (p.name === "bind") {
554 const exp = p.exp;
555 if (exp.content[0] === "_") {
556 res += ` ${p.arg.content}="__VUE_EXP_START__${exp.content}__VUE_EXP_END__"`;
557 continue;
558 }
559 if (shared.isBooleanAttr(p.arg.content) && exp.content === "false") {
560 continue;
561 }
562 let evaluated = evaluateConstant(exp);
563 if (evaluated != null) {
564 const arg = p.arg && p.arg.content;
565 if (arg === "class") {
566 evaluated = shared.normalizeClass(evaluated);
567 } else if (arg === "style") {
568 evaluated = shared.stringifyStyle(shared.normalizeStyle(evaluated));
569 }
570 res += ` ${p.arg.content}="${shared.escapeHtml(
571 evaluated
572 )}"`;
573 }
574 } else if (p.name === "html") {
575 innerHTML = evaluateConstant(p.exp);
576 } else if (p.name === "text") {
577 innerHTML = shared.escapeHtml(
578 shared.toDisplayString(evaluateConstant(p.exp))
579 );
580 }
581 }
582 }
583 if (context.scopeId) {
584 res += ` ${context.scopeId}`;
585 }
586 res += `>`;
587 if (innerHTML) {
588 res += innerHTML;
589 } else {
590 for (let i = 0; i < node.children.length; i++) {
591 res += stringifyNode(node.children[i], context);
592 }
593 }
594 if (!shared.isVoidTag(node.tag)) {
595 res += `</${node.tag}>`;
596 }
597 return res;
598}
599function evaluateConstant(exp) {
600 if (exp.type === 4) {
601 return new Function(`return (${exp.content})`)();
602 } else {
603 let res = ``;
604 exp.children.forEach((c) => {
605 if (shared.isString(c) || shared.isSymbol(c)) {
606 return;
607 }
608 if (c.type === 2) {
609 res += c.content;
610 } else if (c.type === 5) {
611 res += shared.toDisplayString(evaluateConstant(c.content));
612 } else {
613 res += evaluateConstant(c);
614 }
615 });
616 return res;
617 }
618}
619
620const ignoreSideEffectTags = (node, context) => {
621 if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
622 context.removeNode();
623 }
624};
625
626const DOMNodeTransforms = [
627 transformStyle,
628 ...[]
629];
630const DOMDirectiveTransforms = {
631 cloak: compilerCore.noopDirectiveTransform,
632 html: transformVHtml,
633 text: transformVText,
634 model: transformModel,
635 // override compiler-core
636 on: transformOn,
637 // override compiler-core
638 show: transformShow
639};
640function compile(src, options = {}) {
641 return compilerCore.baseCompile(
642 src,
643 shared.extend({}, parserOptions, options, {
644 nodeTransforms: [
645 // ignore <script> and <tag>
646 // this is not put inside DOMNodeTransforms because that list is used
647 // by compiler-ssr to generate vnode fallback branches
648 ignoreSideEffectTags,
649 ...DOMNodeTransforms,
650 ...options.nodeTransforms || []
651 ],
652 directiveTransforms: shared.extend(
653 {},
654 DOMDirectiveTransforms,
655 options.directiveTransforms || {}
656 ),
657 transformHoist: stringifyStatic
658 })
659 );
660}
661function parse(template, options = {}) {
662 return compilerCore.baseParse(template, shared.extend({}, parserOptions, options));
663}
664
665exports.DOMDirectiveTransforms = DOMDirectiveTransforms;
666exports.DOMErrorCodes = DOMErrorCodes;
667exports.DOMErrorMessages = DOMErrorMessages;
668exports.DOMNodeTransforms = DOMNodeTransforms;
669exports.TRANSITION = TRANSITION;
670exports.TRANSITION_GROUP = TRANSITION_GROUP;
671exports.V_MODEL_CHECKBOX = V_MODEL_CHECKBOX;
672exports.V_MODEL_DYNAMIC = V_MODEL_DYNAMIC;
673exports.V_MODEL_RADIO = V_MODEL_RADIO;
674exports.V_MODEL_SELECT = V_MODEL_SELECT;
675exports.V_MODEL_TEXT = V_MODEL_TEXT;
676exports.V_ON_WITH_KEYS = V_ON_WITH_KEYS;
677exports.V_ON_WITH_MODIFIERS = V_ON_WITH_MODIFIERS;
678exports.V_SHOW = V_SHOW;
679exports.compile = compile;
680exports.createDOMCompilerError = createDOMCompilerError;
681exports.parse = parse;
682exports.parserOptions = parserOptions;
683exports.transformStyle = transformStyle;
684Object.keys(compilerCore).forEach(function (k) {
685 if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = compilerCore[k];
686});
Note: See TracBrowser for help on using the repository browser.