first commit

app_vue/node_modules/@vue/vue-loader-v15/lib/codegen/customBlocks.js

@@ -0,0 +1,44 @@
+const qs = require('querystring')
+const { attrsToQuery, genMatchResource } = require('./utils')
+
+module.exports = function genCustomBlocksCode(
+  loaderContext,
+  blocks,
+  resourcePath,
+  resourceQuery,
+  stringifyRequest,
+  enableInlineMatchResource
+) {
+  return (
+    `\n/* custom blocks */\n` +
+    blocks
+      .map((block, i) => {
+        const src = block.attrs.src || resourcePath
+        const attrsQuery = attrsToQuery(block.attrs)
+        const issuerQuery = block.attrs.src
+          ? `&issuerPath=${qs.escape(resourcePath)}`
+          : ''
+        const inheritQuery = resourceQuery ? `&${resourceQuery.slice(1)}` : ''
+        const externalQuery = block.attrs.src ? `&external` : ``
+        const query = `?vue&type=custom&index=${i}&blockType=${qs.escape(
+          block.type
+        )}${issuerQuery}${attrsQuery}${inheritQuery}${externalQuery}`
+
+        let customRequest
+
+        if (enableInlineMatchResource) {
+          customRequest = stringifyRequest(
+            genMatchResource(loaderContext, src, query, block.attrs.lang)
+          )
+        } else {
+          customRequest = stringifyRequest(src + query)
+        }
+        return (
+          `import block${i} from ${customRequest}\n` +
+          `if (typeof block${i} === 'function') block${i}(component)`
+        )
+      })
+      .join(`\n`) +
+    `\n`
+  )
+}

app_vue/node_modules/@vue/vue-loader-v15/lib/codegen/hotReload.js

@@ -0,0 +1,31 @@
+const hotReloadAPIPath = JSON.stringify(require.resolve('vue-hot-reload-api'))
+
+const genTemplateHotReloadCode = (id, request) => {
+  return `
+    module.hot.accept(${request}, function () {
+      api.rerender('${id}', {
+        render: render,
+        staticRenderFns: staticRenderFns
+      })
+    })
+  `.trim()
+}
+
+exports.genHotReloadCode = (id, functional, templateRequest) => {
+  return `
+/* hot reload */
+if (module.hot) {
+  var api = require(${hotReloadAPIPath})
+  api.install(require('vue'))
+  if (api.compatible) {
+    module.hot.accept()
+    if (!api.isRecorded('${id}')) {
+      api.createRecord('${id}', component.options)
+    } else {
+      api.${functional ? 'rerender' : 'reload'}('${id}', component.options)
+    }
+    ${templateRequest ? genTemplateHotReloadCode(id, templateRequest) : ''}
+  }
+}
+  `.trim()
+}

app_vue/node_modules/@vue/vue-loader-v15/lib/codegen/styleInjection.js

@@ -0,0 +1,140 @@
+const { attrsToQuery, genMatchResource } = require('./utils')
+const hotReloadAPIPath = JSON.stringify(require.resolve('vue-hot-reload-api'))
+const nonWhitespaceRE = /\S+/
+
+module.exports = function genStyleInjectionCode(
+  loaderContext,
+  styles,
+  id,
+  resourcePath,
+  stringifyRequest,
+  needsHotReload,
+  needsExplicitInjection,
+  isProduction,
+  enableInlineMatchResource
+) {
+  let styleImportsCode = ``
+  let styleInjectionCode = ``
+  let cssModulesHotReloadCode = ``
+
+  let hasCSSModules = false
+  const cssModuleNames = new Map()
+
+  function genStyleRequest(style, i) {
+    const src = style.src || resourcePath
+    const attrsQuery = attrsToQuery(style.attrs, 'css')
+    const lang = String(style.attrs.lang || 'css')
+    const inheritQuery = loaderContext.resourceQuery.slice(1)
+      ? `&${loaderContext.resourceQuery.slice(1)}`
+      : ''
+    // make sure to only pass id not src importing so that we don't inject
+    // duplicate tags when multiple components import the same css file
+    const idQuery = !style.src || style.scoped ? `&id=${id}` : ``
+    const prodQuery = isProduction ? `&prod` : ``
+    const externalQuery = style.src ? `&external` : ``
+    const query = `?vue&type=style&index=${i}${idQuery}${prodQuery}${attrsQuery}${inheritQuery}${externalQuery}`
+    let styleRequest
+    if (enableInlineMatchResource) {
+      styleRequest = stringifyRequest(genMatchResource(loaderContext, src, query, lang))
+    } else {
+      styleRequest = stringifyRequest(src + query)
+    }
+    return styleRequest
+  }
+
+  function genCSSModulesCode(style, request, i) {
+    hasCSSModules = true
+
+    const moduleName = style.module === true ? '$style' : style.module
+    if (cssModuleNames.has(moduleName)) {
+      loaderContext.emitError(`CSS module name ${moduleName} is not unique!`)
+    }
+    cssModuleNames.set(moduleName, true)
+
+    // `(vue-)style-loader` exports the name-to-hash map directly
+    // `css-loader` exports it in `.locals`
+    const locals = `(style${i}.locals || style${i})`
+    const name = JSON.stringify(moduleName)
+
+    if (!needsHotReload) {
+      styleInjectionCode += `this[${name}] = ${locals}\n`
+    } else {
+      styleInjectionCode += `
+        cssModules[${name}] = ${locals}
+        Object.defineProperty(this, ${name}, {
+          configurable: true,
+          get: function () {
+            return cssModules[${name}]
+          }
+        })
+      `
+      cssModulesHotReloadCode += `
+        module.hot && module.hot.accept([${request}], function () {
+          var oldLocals = cssModules[${name}]
+          if (oldLocals) {
+            var newLocals = require(${request})
+            if (JSON.stringify(newLocals) !== JSON.stringify(oldLocals)) {
+              cssModules[${name}] = newLocals
+              require(${hotReloadAPIPath}).rerender("${id}")
+            }
+          }
+        })
+      `
+    }
+  }
+
+  // empty styles: with no `src` specified or only contains whitespaces
+  const isNotEmptyStyle = (style) =>
+    style.src || nonWhitespaceRE.test(style.content)
+  // explicit injection is needed in SSR (for critical CSS collection)
+  // or in Shadow Mode (for injection into shadow root)
+  // In these modes, vue-style-loader exports objects with the __inject__
+  // method; otherwise we simply import the styles.
+  if (!needsExplicitInjection) {
+    styles.forEach((style, i) => {
+      // do not generate requests for empty styles
+      if (isNotEmptyStyle(style)) {
+        const request = genStyleRequest(style, i)
+        styleImportsCode += `import style${i} from ${request}\n`
+        if (style.module) genCSSModulesCode(style, request, i)
+      }
+    })
+  } else {
+    styles.forEach((style, i) => {
+      if (isNotEmptyStyle(style)) {
+        const request = genStyleRequest(style, i)
+        styleInjectionCode +=
+          `var style${i} = require(${request})\n` +
+          `if (style${i}.__inject__) style${i}.__inject__(context)\n`
+        if (style.module) genCSSModulesCode(style, request, i)
+      }
+    })
+  }
+
+  if (!needsExplicitInjection && !hasCSSModules) {
+    return styleImportsCode
+  }
+
+  return `
+${styleImportsCode}
+${hasCSSModules && needsHotReload ? `var cssModules = {}` : ``}
+${needsHotReload ? `var disposed = false` : ``}
+
+function injectStyles (context) {
+  ${needsHotReload ? `if (disposed) return` : ``}
+  ${styleInjectionCode}
+}
+
+${
+  needsHotReload
+    ? `
+  module.hot && module.hot.dispose(function (data) {
+    disposed = true
+  })
+`
+    : ``
+}
+
+${cssModulesHotReloadCode}
+  `.trim()
+}

app_vue/node_modules/@vue/vue-loader-v15/lib/codegen/utils.js

@@ -0,0 +1,48 @@
+const qs = require('querystring')
+
+// these are built-in query parameters so should be ignored
+// if the user happen to add them as attrs
+const ignoreList = ['id', 'index', 'src', 'type']
+
+// transform the attrs on a SFC block descriptor into a resourceQuery string
+exports.attrsToQuery = (attrs, langFallback) => {
+  let query = ``
+  for (const name in attrs) {
+    const value = attrs[name]
+    if (!ignoreList.includes(name)) {
+      query += `&${qs.escape(name)}=${value ? qs.escape(value) : ``}`
+    }
+  }
+  if (langFallback && !(`lang` in attrs)) {
+    query += `&lang=${langFallback}`
+  }
+  return query
+}
+
+exports.genMatchResource = (context, resourcePath, resourceQuery, lang) => {
+  resourceQuery = resourceQuery || ''
+
+  const loaders = []
+  const parsedQuery = qs.parse(resourceQuery.slice(1))
+
+  // process non-external resources
+  if ('vue' in parsedQuery && !('external' in parsedQuery)) {
+    const currentRequest = context.loaders
+      .slice(context.loaderIndex)
+      .map((obj) => obj.request)
+    loaders.push(...currentRequest)
+  }
+  const loaderString = loaders.join('!')
+
+  return `${resourcePath}${lang ? `.${lang}` : ''}${resourceQuery}!=!${
+    loaderString ? `${loaderString}!` : ''
+  }${resourcePath}${resourceQuery}`
+}
+
+exports.testWebpack5 = (compiler) => {
+  if (!compiler) {
+    return false
+  }
+  const webpackVersion = compiler.webpack && compiler.webpack.version
+  return Boolean(webpackVersion && Number(webpackVersion.split('.')[0]) > 4)
+}

app_vue/node_modules/@vue/vue-loader-v15/lib/compiler.js

@@ -0,0 +1,54 @@
+// resolve compilers to use.
+
+let cached
+
+exports.resolveCompiler = function (ctx, loaderContext) {
+  if (cached) {
+    return cached
+  }
+
+  // check 2.7
+  try {
+    const pkg = loadFromContext('vue/package.json', ctx)
+    const [major, minor] = pkg.version.split('.')
+    if (major === '2' && Number(minor) >= 7) {
+      return (cached = {
+        is27: true,
+        compiler: loadFromContext('vue/compiler-sfc', ctx),
+        templateCompiler: undefined
+      })
+    }
+  } catch (e) {}
+
+  return (cached = {
+    compiler: require('@vue/component-compiler-utils'),
+    templateCompiler: loadTemplateCompiler(ctx, loaderContext)
+  })
+}
+
+function loadFromContext(path, ctx) {
+  return require(require.resolve(path, {
+    paths: [ctx]
+  }))
+}
+
+function loadTemplateCompiler(ctx, loaderContext) {
+  try {
+    return loadFromContext('vue-template-compiler', ctx)
+  } catch (e) {
+    if (loaderContext) {
+      if (/version mismatch/.test(e.toString())) {
+        loaderContext.emitError(e)
+      } else {
+        loaderContext.emitError(
+          new Error(
+            `[vue-loader] vue-template-compiler must be installed as a peer dependency, ` +
+              `or a compatible compiler implementation must be passed via options.`
+          )
+        )
+      }
+    } else {
+      throw e
+    }
+  }
+}

app_vue/node_modules/@vue/vue-loader-v15/lib/descriptorCache.js

@@ -0,0 +1,47 @@
+const fs = require('fs')
+const path = require('path')
+const { resolveCompiler } = require('./compiler')
+
+const cache = new Map()
+
+exports.setDescriptor = function setDescriptor(filename, entry) {
+  cache.set(cleanQuery(filename), entry)
+}
+
+exports.getDescriptor = function getDescriptor(
+  filename,
+  options,
+  loaderContext
+) {
+  filename = cleanQuery(filename)
+  if (cache.has(filename)) {
+    return cache.get(filename)
+  }
+
+  // This function should only be called after the descriptor has been
+  // cached by the main loader.
+  // If this is somehow called without a cache hit, it's probably due to sub
+  // loaders being run in separate threads. The only way to deal with this is to
+  // read from disk directly...
+  const source = fs.readFileSync(filename, 'utf-8')
+  const sourceRoot = path.dirname(
+    path.relative(loaderContext.rootContext, loaderContext.resourcePath)
+  )
+  const { compiler, templateCompiler } = resolveCompiler(
+    loaderContext.rootContext
+  )
+  const descriptor = compiler.parse({
+    source,
+    compiler: options.compiler || templateCompiler,
+    filename,
+    sourceRoot,
+    needMap: loaderContext.sourceMap
+  })
+  cache.set(filename, descriptor)
+  return descriptor
+}
+
+function cleanQuery(str) {
+  const i = str.indexOf('?')
+  return i > 0 ? str.slice(0, i) : str
+}

app_vue/node_modules/@vue/vue-loader-v15/lib/index.d.ts

@@ -0,0 +1,25 @@
+import { Plugin } from 'webpack'
+import { VueTemplateCompiler } from '@vue/component-compiler-utils/dist/types'
+import { CompilerOptions } from 'vue-template-compiler'
+
+declare namespace VueLoader {
+  class VueLoaderPlugin extends Plugin {}
+
+  interface VueLoaderOptions {
+    transformAssetUrls?: { [tag: string]: string | Array<string> }
+    compiler?: VueTemplateCompiler
+    compilerOptions?: CompilerOptions
+    transpileOptions?: Object
+    optimizeSSR?: boolean
+    hotReload?: boolean
+    productionMode?: boolean
+    shadowMode?: boolean
+    cacheDirectory?: string
+    cacheIdentifier?: string
+    prettify?: boolean
+    exposeFilename?: boolean
+    experimentalInlineMatchResource?: boolean
+  }
+}
+
+export = VueLoader

app_vue/node_modules/@vue/vue-loader-v15/lib/index.js

@@ -0,0 +1,231 @@
+const path = require('path')
+const hash = require('hash-sum')
+const qs = require('querystring')
+const plugin = require('./plugin')
+const selectBlock = require('./select')
+const loaderUtils = require('loader-utils')
+const {
+  attrsToQuery,
+  testWebpack5,
+  genMatchResource
+} = require('./codegen/utils')
+const genStylesCode = require('./codegen/styleInjection')
+const { genHotReloadCode } = require('./codegen/hotReload')
+const genCustomBlocksCode = require('./codegen/customBlocks')
+const componentNormalizerPath = require.resolve('./runtime/componentNormalizer')
+const { NS } = require('./plugin')
+const { resolveCompiler } = require('./compiler')
+const { setDescriptor } = require('./descriptorCache')
+
+let errorEmitted = false
+
+module.exports = function (source) {
+  const loaderContext = this
+
+  if (!errorEmitted && !loaderContext['thread-loader'] && !loaderContext[NS]) {
+    loaderContext.emitError(
+      new Error(
+        `vue-loader was used without the corresponding plugin. ` +
+          `Make sure to include VueLoaderPlugin in your webpack config.`
+      )
+    )
+    errorEmitted = true
+  }
+
+  const stringifyRequest = (r) => loaderUtils.stringifyRequest(loaderContext, r)
+
+  const {
+    mode,
+    target,
+    request,
+    minimize,
+    sourceMap,
+    rootContext,
+    resourcePath,
+    resourceQuery: _resourceQuery = '',
+    _compiler
+  } = loaderContext
+  const isWebpack5 = testWebpack5(_compiler)
+  const rawQuery = _resourceQuery.slice(1)
+  const resourceQuery = rawQuery ? `&${rawQuery}` : ''
+  const incomingQuery = qs.parse(rawQuery)
+  const options = loaderUtils.getOptions(loaderContext) || {}
+  const enableInlineMatchResource =
+    isWebpack5 && Boolean(options.experimentalInlineMatchResource)
+  const isServer = target === 'node'
+  const isShadow = !!options.shadowMode
+  const isProduction =
+    mode === 'production' ||
+    options.productionMode ||
+    minimize ||
+    process.env.NODE_ENV === 'production'
+
+  const filename = path.basename(resourcePath)
+  const context = rootContext || process.cwd()
+  const sourceRoot = path.dirname(path.relative(context, resourcePath))
+
+  const { compiler, templateCompiler } = resolveCompiler(context, loaderContext)
+
+  const descriptor = compiler.parse({
+    source,
+    compiler: options.compiler || templateCompiler,
+    filename,
+    sourceRoot,
+    needMap: sourceMap
+  })
+
+  // cache descriptor
+  setDescriptor(resourcePath, descriptor)
+
+  // module id for scoped CSS & hot-reload
+  const rawShortFilePath = path
+    .relative(context, resourcePath)
+    .replace(/^(\.\.[\/\\])+/, '')
+  const shortFilePath = rawShortFilePath.replace(/\\/g, '/')
+  const id = hash(
+    isProduction
+      ? shortFilePath + '\n' + source.replace(/\r\n/g, '\n')
+      : shortFilePath
+  )
+
+  // if the query has a type field, this is a language block request
+  // e.g. foo.vue?type=template&id=xxxxx
+  // and we will return early
+  if (incomingQuery.type) {
+    return selectBlock(
+      descriptor,
+      id,
+      options,
+      loaderContext,
+      incomingQuery,
+      !!options.appendExtension
+    )
+  }
+
+  // feature information
+  const hasScoped = descriptor.styles.some((s) => s.scoped)
+  const hasFunctional =
+    descriptor.template && descriptor.template.attrs.functional
+  const needsHotReload =
+    !isServer &&
+    !isProduction &&
+    (descriptor.script || descriptor.scriptSetup || descriptor.template) &&
+    options.hotReload !== false
+
+  // script
+  let scriptImport = `var script = {}`
+  // let isTS = false
+  const { script, scriptSetup } = descriptor
+  if (script || scriptSetup) {
+    const lang = (script && script.lang) || (scriptSetup && scriptSetup.lang)
+    // isTS = !!(lang && /tsx?/.test(lang))
+    const externalQuery =
+      script && !scriptSetup && script.src ? `&external` : ``
+    const src = (script && !scriptSetup && script.src) || resourcePath
+    const attrsQuery = attrsToQuery((scriptSetup || script).attrs, 'js')
+    const query = `?vue&type=script${attrsQuery}${resourceQuery}${externalQuery}`
+
+    let scriptRequest
+    if (enableInlineMatchResource) {
+      scriptRequest = stringifyRequest(
+        genMatchResource(loaderContext, src, query, lang || 'js')
+      )
+    } else {
+      scriptRequest = stringifyRequest(src + query)
+    }
+    scriptImport =
+      `import script from ${scriptRequest}\n` + `export * from ${scriptRequest}` // support named exports
+  }
+
+  // template
+  let templateImport = `var render, staticRenderFns`
+  let templateRequest
+  if (descriptor.template) {
+    const src = descriptor.template.src || resourcePath
+    const externalQuery = descriptor.template.src ? `&external` : ``
+    const idQuery = `&id=${id}`
+    const scopedQuery = hasScoped ? `&scoped=true` : ``
+    const attrsQuery = attrsToQuery(descriptor.template.attrs)
+    // const tsQuery =
+    // options.enableTsInTemplate !== false && isTS ? `&ts=true` : ``
+    const query = `?vue&type=template${idQuery}${scopedQuery}${attrsQuery}${resourceQuery}${externalQuery}`
+    if (enableInlineMatchResource) {
+      templateRequest = stringifyRequest(
+        // TypeScript syntax in template expressions is not supported in Vue 2, so the lang is always 'js'
+        genMatchResource(loaderContext, src, query, 'js')
+      )
+    } else {
+      templateRequest = stringifyRequest(src + query)
+    }
+    templateImport = `import { render, staticRenderFns } from ${templateRequest}`
+  }
+
+  // styles
+  let stylesCode = ``
+  if (descriptor.styles.length) {
+    stylesCode = genStylesCode(
+      loaderContext,
+      descriptor.styles,
+      id,
+      resourcePath,
+      stringifyRequest,
+      needsHotReload,
+      isServer || isShadow, // needs explicit injection?
+      isProduction,
+      enableInlineMatchResource
+    )
+  }
+
+  let code =
+    `
+${templateImport}
+${scriptImport}
+${stylesCode}
+
+/* normalize component */
+import normalizer from ${stringifyRequest(`!${componentNormalizerPath}`)}
+var component = normalizer(
+  script,
+  render,
+  staticRenderFns,
+  ${hasFunctional ? `true` : `false`},
+  ${/injectStyles/.test(stylesCode) ? `injectStyles` : `null`},
+  ${hasScoped ? JSON.stringify(id) : `null`},
+  ${isServer ? JSON.stringify(hash(request)) : `null`}
+  ${isShadow ? `,true` : ``}
+)
+  `.trim() + `\n`
+
+  if (descriptor.customBlocks && descriptor.customBlocks.length) {
+    code += genCustomBlocksCode(
+      loaderContext,
+      descriptor.customBlocks,
+      resourcePath,
+      resourceQuery,
+      stringifyRequest,
+      enableInlineMatchResource
+    )
+  }
+
+  if (needsHotReload) {
+    code += `\n` + genHotReloadCode(id, hasFunctional, templateRequest)
+  }
+
+  // Expose filename. This is used by the devtools and Vue runtime warnings.
+  if (!isProduction) {
+    // Expose the file's full path in development, so that it can be opened
+    // from the devtools.
+    code += `\ncomponent.options.__file = ${JSON.stringify(
+      rawShortFilePath.replace(/\\/g, '/')
+    )}`
+  } else if (options.exposeFilename) {
+    // Libraries can opt-in to expose their components' filenames in production builds.
+    // For security reasons, only expose the file's basename in production.
+    code += `\ncomponent.options.__file = ${JSON.stringify(filename)}`
+  }
+
+  code += `\nexport default component.exports`
+  return code
+}
+
+module.exports.VueLoaderPlugin = plugin

app_vue/node_modules/@vue/vue-loader-v15/lib/loaders/pitcher.js

@@ -0,0 +1,223 @@
+const qs = require('querystring')
+const loaderUtils = require('loader-utils')
+const hash = require('hash-sum')
+const selfPath = require.resolve('../index')
+const templateLoaderPath = require.resolve('./templateLoader')
+const stylePostLoaderPath = require.resolve('./stylePostLoader')
+const { resolveCompiler } = require('../compiler')
+const { testWebpack5 } = require('../codegen/utils')
+
+const isESLintLoader = (l) => /(\/|\\|@)eslint-loader/.test(l.path)
+const isNullLoader = (l) => /(\/|\\|@)null-loader/.test(l.path)
+const isCSSLoader = (l) => /(\/|\\|@)css-loader/.test(l.path)
+const isCacheLoader = (l) => /(\/|\\|@)cache-loader/.test(l.path)
+const isPitcher = (l) => l.path !== __filename
+const isPreLoader = (l) => !l.pitchExecuted
+const isPostLoader = (l) => l.pitchExecuted
+
+const dedupeESLintLoader = (loaders) => {
+  const res = []
+  let seen = false
+  loaders.forEach((l) => {
+    if (!isESLintLoader(l)) {
+      res.push(l)
+    } else if (!seen) {
+      seen = true
+      res.push(l)
+    }
+  })
+  return res
+}
+
+const shouldIgnoreCustomBlock = (loaders) => {
+  const actualLoaders = loaders.filter((loader) => {
+    // vue-loader
+    if (loader.path === selfPath) {
+      return false
+    }
+
+    // cache-loader
+    if (isCacheLoader(loader)) {
+      return false
+    }
+
+    return true
+  })
+  return actualLoaders.length === 0
+}
+
+module.exports = (code) => code
+
+// This pitching loader is responsible for intercepting all vue block requests
+// and transform it into appropriate requests.
+module.exports.pitch = function (remainingRequest) {
+  const options = loaderUtils.getOptions(this)
+  const { cacheDirectory, cacheIdentifier } = options
+  const query = qs.parse(this.resourceQuery.slice(1))
+  const isWebpack5 = testWebpack5(this._compiler)
+
+  let loaders = this.loaders
+
+  // if this is a language block request, eslint-loader may get matched
+  // multiple times
+  if (query.type) {
+    // if this is an inline block, since the whole file itself is being linted,
+    // remove eslint-loader to avoid duplicate linting.
+    if (/\.vue$/.test(this.resourcePath)) {
+      loaders = loaders.filter((l) => !isESLintLoader(l))
+    } else {
+      // This is a src import. Just make sure there's not more than 1 instance
+      // of eslint present.
+      loaders = dedupeESLintLoader(loaders)
+    }
+  }
+
+  // remove self
+  loaders = loaders.filter(isPitcher)
+
+  // do not inject if user uses null-loader to void the type (#1239)
+  if (loaders.some(isNullLoader)) {
+    return
+  }
+
+  const genRequest = (loaders, lang) => {
+    // Important: dedupe since both the original rule
+    // and the cloned rule would match a source import request.
+    // also make sure to dedupe based on loader path.
+    // assumes you'd probably never want to apply the same loader on the same
+    // file twice.
+    // Exception: in Vue CLI we do need two instances of postcss-loader
+    // for user config and inline minification. So we need to dedupe baesd on
+    // path AND query to be safe.
+    const seen = new Map()
+    const loaderStrings = []
+    const enableInlineMatchResource =
+      isWebpack5 && options.experimentalInlineMatchResource
+
+    loaders.forEach((loader) => {
+      const identifier =
+        typeof loader === 'string' ? loader : loader.path + loader.query
+      const request = typeof loader === 'string' ? loader : loader.request
+      if (!seen.has(identifier)) {
+        seen.set(identifier, true)
+        // loader.request contains both the resolved loader path and its options
+        // query (e.g. ??ref-0)
+        loaderStrings.push(request)
+      }
+    })
+    if (enableInlineMatchResource) {
+      return loaderUtils.stringifyRequest(
+        this,
+        `${this.resourcePath}${lang ? `.${lang}` : ''}${
+          this.resourceQuery
+        }!=!-!${[...loaderStrings, this.resourcePath + this.resourceQuery].join('!')}`
+      )
+    }
+
+    return loaderUtils.stringifyRequest(
+      this,
+      '-!' +
+        [...loaderStrings, this.resourcePath + this.resourceQuery].join('!')
+    )
+  }
+
+  // Inject style-post-loader before css-loader for scoped CSS and trimming
+  if (query.type === `style`) {
+    if (isWebpack5 && this._compiler.options.experiments && this._compiler.options.experiments.css) {
+      // If user enables `experiments.css`, then we are trying to emit css code directly.
+      // Although we can target requests like `xxx.vue?type=style` to match `type: "css"`,
+      // it will make the plugin a mess.
+      if (!options.experimentalInlineMatchResource) {
+        this.emitError(
+          new Error(
+            '`experimentalInlineMatchResource` should be enabled if `experiments.css` enabled currently'
+          )
+        )
+        return ''
+      }
+
+      if (query.inline || query.module) {
+        this.emitError(
+          new Error(
+            '`inline` or `module` is currently not supported with `experiments.css` enabled'
+          )
+        )
+        return ''
+      }
+
+      const loaderString = [stylePostLoaderPath, ...loaders]
+        .map((loader) => {
+          return typeof loader === 'string' ? loader : loader.request
+        })
+        .join('!')
+
+        const styleRequest = loaderUtils.stringifyRequest(
+          this,
+          `${this.resourcePath}${query.lang ? `.${query.lang}` : ''}${
+            this.resourceQuery
+          }!=!-!${loaderString}!${this.resourcePath + this.resourceQuery}`
+        )
+        return `@import ${styleRequest};`
+    }
+
+    const cssLoaderIndex = loaders.findIndex(isCSSLoader)
+    if (cssLoaderIndex > -1) {
+      const afterLoaders = loaders.slice(0, cssLoaderIndex + 1)
+      const beforeLoaders = loaders.slice(cssLoaderIndex + 1)
+      const request = genRequest(
+        [...afterLoaders, stylePostLoaderPath, ...beforeLoaders],
+        query.lang || 'css'
+      )
+      // console.log(request)
+      return query.module
+        ? `export { default } from  ${request}; export * from ${request}`
+        : `export * from ${request}`
+    }
+  }
+
+  // for templates: inject the template compiler & optional cache
+  if (query.type === `template`) {
+    const path = require('path')
+    const cacheLoader =
+      cacheDirectory && cacheIdentifier
+        ? [
+            `${require.resolve('cache-loader')}?${JSON.stringify({
+              // For some reason, webpack fails to generate consistent hash if we
+              // use absolute paths here, even though the path is only used in a
+              // comment. For now we have to ensure cacheDirectory is a relative path.
+              cacheDirectory: (path.isAbsolute(cacheDirectory)
+                ? path.relative(process.cwd(), cacheDirectory)
+                : cacheDirectory
+              ).replace(/\\/g, '/'),
+              cacheIdentifier: hash(cacheIdentifier) + '-vue-loader-template'
+            })}`
+          ]
+        : []
+
+    const preLoaders = loaders.filter(isPreLoader)
+    const postLoaders = loaders.filter(isPostLoader)
+    const { is27 } = resolveCompiler(this.rootContext, this)
+
+    const request = genRequest([
+      ...cacheLoader,
+      ...postLoaders,
+      ...(is27 ? [] : [templateLoaderPath + `??vue-loader-options`]),
+      ...preLoaders
+    ])
+
+    // the template compiler uses esm exports
+    return `export * from ${request}`
+  }
+
+  // if a custom block has no other matching loader other than vue-loader itself
+  // or cache-loader, we should ignore it
+  if (query.type === `custom` && shouldIgnoreCustomBlock(loaders)) {
+    return ``
+  }
+
+  // When the user defines a rule that has only resourceQuery but no test,
+  // both that rule and the cloned rule will match, resulting in duplicated
+  // loaders. Therefore it is necessary to perform a dedupe here.
+  const request = genRequest(loaders)
+  return `import mod from ${request}; export default mod; export * from ${request}`
+}

app_vue/node_modules/@vue/vue-loader-v15/lib/loaders/stylePostLoader.js

@@ -0,0 +1,25 @@
+const qs = require('querystring')
+const { resolveCompiler } = require('../compiler')
+
+// This is a post loader that handles scoped CSS transforms.
+// Injected right before css-loader by the global pitcher (../pitch.js)
+// for any <style scoped> selection requests initiated from within vue files.
+module.exports = function (source, inMap) {
+  const query = qs.parse(this.resourceQuery.slice(1))
+  const { compiler } = resolveCompiler(this.rootContext, this)
+  const { code, map, errors } = compiler.compileStyle({
+    source,
+    filename: this.resourcePath,
+    id: `data-v-${query.id}`,
+    map: inMap,
+    scoped: !!query.scoped,
+    isProd: query.prod != null,
+    trim: true
+  })
+
+  if (errors.length) {
+    this.callback(errors[0])
+  } else {
+    this.callback(null, code, map)
+  }
+}

app_vue/node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js

@@ -0,0 +1,119 @@
+const qs = require('querystring')
+const loaderUtils = require('loader-utils')
+const { resolveCompiler } = require('../compiler')
+const { getDescriptor } = require('../descriptorCache')
+const { resolveScript } = require('../resolveScript')
+
+// Loader that compiles raw template into JavaScript functions.
+// This is injected by the global pitcher (../pitch) for template
+// selection requests initiated from vue files.
+module.exports = function (source) {
+  const loaderContext = this
+  const filename = this.resourcePath
+  const ctx = this.rootContext
+  const query = qs.parse(this.resourceQuery.slice(1))
+
+  // although this is not the main vue-loader, we can get access to the same
+  // vue-loader options because we've set an ident in the plugin and used that
+  // ident to create the request for this loader in the pitcher.
+  const options = loaderUtils.getOptions(loaderContext) || {}
+  const { id } = query
+  const isServer = loaderContext.target === 'node'
+  const isProduction =
+    options.productionMode ||
+    loaderContext.minimize ||
+    process.env.NODE_ENV === 'production'
+  const isFunctional = query.functional
+
+  const compilerOptions = Object.assign(
+    {
+      outputSourceRange: true
+    },
+    options.compilerOptions,
+    {
+      scopeId: query.scoped ? `data-v-${id}` : null,
+      comments: query.comments
+    }
+  )
+
+  const { compiler, templateCompiler } = resolveCompiler(ctx, loaderContext)
+
+  const descriptor = getDescriptor(filename, options, loaderContext)
+  const script = resolveScript(descriptor, id, options, loaderContext)
+
+  // Prettier 3 APIs are all async
+  // but `vue/compiler-sfc` and `@vue/component-compiler-utils` can only use sync function to format code
+  let hasCompatiblePrettier = false
+  try {
+    const prettier = require('prettier/package.json')
+    const major = parseInt(prettier.version.split('.')[0], 10)
+    if (major === 1 || major === 2) {
+      hasCompatiblePrettier = true
+    }
+  } catch (e) {}
+
+  // for vue/compiler-sfc OR @vue/component-compiler-utils
+  const finalOptions = {
+    source,
+    filename: this.resourcePath,
+    compiler: options.compiler || templateCompiler,
+    compilerOptions,
+    // allow customizing behavior of vue-template-es2015-compiler
+    transpileOptions: options.transpileOptions,
+    transformAssetUrls: options.transformAssetUrls || true,
+    isProduction,
+    isFunctional,
+    optimizeSSR: isServer && options.optimizeSSR !== false,
+    prettify: options.prettify === undefined ? hasCompatiblePrettier : options.prettify,
+    bindings: script ? script.bindings : undefined
+  }
+
+  const compiled = compiler.compileTemplate(finalOptions)
+
+  // tips
+  if (compiled.tips && compiled.tips.length) {
+    compiled.tips.forEach((tip) => {
+      loaderContext.emitWarning(typeof tip === 'object' ? tip.msg : tip)
+    })
+  }
+
+  // errors
+  if (compiled.errors && compiled.errors.length) {
+    const generateCodeFrame =
+      (templateCompiler && templateCompiler.generateCodeFrame) ||
+      compiler.generateCodeFrame
+    // 2.6 compiler outputs errors as objects with range
+    if (generateCodeFrame && finalOptions.compilerOptions.outputSourceRange) {
+      // TODO account for line offset in case template isn't placed at top
+      // of the file
+      loaderContext.emitError(
+        `\n\n  Errors compiling template:\n\n` +
+          compiled.errors
+            .map(({ msg, start, end }) => {
+              const frame = generateCodeFrame(source, start, end)
+              return `  ${msg}\n\n${pad(frame)}`
+            })
+            .join(`\n\n`) +
+          '\n'
+      )
+    } else {
+      loaderContext.emitError(
+        `\n  Error compiling template:\n${pad(compiled.source)}\n` +
+          compiled.errors.map((e) => `  - ${e}`).join('\n') +
+          '\n'
+      )
+    }
+  }
+
+  const { code } = compiled
+
+  // finish with ESM exports
+  return code + `\nexport { render, staticRenderFns }`
+}
+
+function pad(source) {
+  return source
+    .split(/\r?\n/)
+    .map((line) => `  ${line}`)
+    .join('\n')
+}

app_vue/node_modules/@vue/vue-loader-v15/lib/plugin-webpack4.js

@@ -0,0 +1,232 @@
+const qs = require('querystring')
+const RuleSet = require('webpack/lib/RuleSet')
+const { resolveCompiler } = require('./compiler')
+
+const id = 'vue-loader-plugin'
+const NS = 'vue-loader'
+
+class VueLoaderPlugin {
+  apply(compiler) {
+    // add NS marker so that the loader can detect and report missing plugin
+    if (compiler.hooks) {
+      // webpack 4
+      compiler.hooks.compilation.tap(id, (compilation) => {
+        const normalModuleLoader = compilation.hooks.normalModuleLoader
+        normalModuleLoader.tap(id, (loaderContext) => {
+          loaderContext[NS] = true
+        })
+      })
+    } else {
+      // webpack < 4
+      compiler.plugin('compilation', (compilation) => {
+        compilation.plugin('normal-module-loader', (loaderContext) => {
+          loaderContext[NS] = true
+        })
+      })
+    }
+
+    // use webpack's RuleSet utility to normalize user rules
+    const rawRules = compiler.options.module.rules
+    const { rules } = new RuleSet(rawRules)
+
+    // find the rule that applies to vue files
+    let vueRuleIndex = rawRules.findIndex(createMatcher(`foo.vue`))
+    if (vueRuleIndex < 0) {
+      vueRuleIndex = rawRules.findIndex(createMatcher(`foo.vue.html`))
+    }
+    const vueRule = rules[vueRuleIndex]
+
+    if (!vueRule) {
+      throw new Error(
+        `[VueLoaderPlugin Error] No matching rule for .vue files found.\n` +
+          `Make sure there is at least one root-level rule that matches .vue or .vue.html files.`
+      )
+    }
+
+    if (vueRule.oneOf) {
+      throw new Error(
+        `[VueLoaderPlugin Error] vue-loader 15 currently does not support vue rules with oneOf.`
+      )
+    }
+
+    // get the normalized "use" for vue files
+    const vueUse = vueRule.use
+    // get vue-loader options
+    const vueLoaderUseIndex = vueUse.findIndex((u) => {
+      return /^vue-loader|(\/|\\|@)vue-loader/.test(u.loader)
+    })
+
+    if (vueLoaderUseIndex < 0) {
+      throw new Error(
+        `[VueLoaderPlugin Error] No matching use for vue-loader is found.\n` +
+          `Make sure the rule matching .vue files include vue-loader in its use.`
+      )
+    }
+
+    // make sure vue-loader options has a known ident so that we can share
+    // options by reference in the template-loader by using a ref query like
+    // template-loader??vue-loader-options
+    const vueLoaderUse = vueUse[vueLoaderUseIndex]
+    vueLoaderUse.ident = 'vue-loader-options'
+    vueLoaderUse.options = vueLoaderUse.options || {}
+
+    // for each user rule (except the vue rule), create a cloned rule
+    // that targets the corresponding language blocks in *.vue files.
+    const clonedRules = rules.filter((r) => r !== vueRule).map(cloneRule)
+
+    // rule for template compiler
+    const templateCompilerRule = {
+      loader: require.resolve('./loaders/templateLoader'),
+      resourceQuery: (query) => {
+        const parsed = qs.parse(query.slice(1))
+        return parsed.vue != null && parsed.type === 'template'
+      },
+      options: vueLoaderUse.options
+    }
+
+    // for each rule that matches plain .js/.ts files, also create a clone and
+    // match it against the compiled template code inside *.vue files, so that
+    // compiled vue render functions receive the same treatment as user code
+    // (mostly babel)
+    const { is27 } = resolveCompiler(compiler.options.context)
+    let jsRulesForRenderFn = []
+    if (is27) {
+      const matchesJS = createMatcher(`test.js`)
+      // const matchesTS = createMatcher(`test.ts`)
+      jsRulesForRenderFn = rules
+        .filter((r) => r !== vueRule && matchesJS(r))
+        .map(cloneRuleForRenderFn)
+    }
+
+    // global pitcher (responsible for injecting template compiler loader & CSS
+    // post loader)
+    const pitcher = {
+      loader: require.resolve('./loaders/pitcher'),
+      resourceQuery: (query) => {
+        const parsed = qs.parse(query.slice(1))
+        return parsed.vue != null
+      },
+      options: {
+        cacheDirectory: vueLoaderUse.options.cacheDirectory,
+        cacheIdentifier: vueLoaderUse.options.cacheIdentifier
+      }
+    }
+
+    // replace original rules
+    compiler.options.module.rules = [
+      pitcher,
+      ...jsRulesForRenderFn,
+      ...(is27 ? [templateCompilerRule] : []),
+      ...clonedRules,
+      ...rules
+    ]
+  }
+}
+
+function createMatcher(fakeFile) {
+  return (rule, i) => {
+    // #1201 we need to skip the `include` check when locating the vue rule
+    const clone = Object.assign({}, rule)
+    delete clone.include
+    const normalized = RuleSet.normalizeRule(clone, {}, '')
+    return !rule.enforce && normalized.resource && normalized.resource(fakeFile)
+  }
+}
+
+function cloneRule(rule) {
+  const { resource, resourceQuery } = rule
+  // Assuming `test` and `resourceQuery` tests are executed in series and
+  // synchronously (which is true based on RuleSet's implementation), we can
+  // save the current resource being matched from `test` so that we can access
+  // it in `resourceQuery`. This ensures when we use the normalized rule's
+  // resource check, include/exclude are matched correctly.
+  let currentResource
+  const res = Object.assign({}, rule, {
+    resource: {
+      test: (resource) => {
+        currentResource = resource
+        return true
+      }
+    },
+    resourceQuery: (query) => {
+      const parsed = qs.parse(query.slice(1))
+      if (parsed.vue == null) {
+        return false
+      }
+      if (resource && parsed.lang == null) {
+        return false
+      }
+      const fakeResourcePath = `${currentResource}.${parsed.lang}`
+      if (resource && !resource(fakeResourcePath)) {
+        return false
+      }
+      if (resourceQuery && !resourceQuery(query)) {
+        return false
+      }
+      return true
+    }
+  })
+
+  if (rule.rules) {
+    res.rules = rule.rules.map(cloneRule)
+  }
+
+  if (rule.oneOf) {
+    res.oneOf = rule.oneOf.map(cloneRule)
+  }
+
+  return res
+}
+
+function cloneRuleForRenderFn(rule) {
+  const resource = rule.resource
+  const resourceQuery = rule.resourceQuery
+  let currentResource
+
+  const res = {
+    ...rule,
+    resource: (resource) => {
+      currentResource = resource
+      return true
+    },
+    resourceQuery: (query) => {
+      const parsed = qs.parse(query.slice(1))
+      if (parsed.vue == null || parsed.type !== 'template') {
+        return false
+      }
+      const fakeResourcePath = `${currentResource}.${parsed.ts ? `ts` : `js`}`
+      if (resource && !resource(fakeResourcePath)) {
+        return false
+      }
+      if (resourceQuery && !resourceQuery(query)) {
+        return false
+      }
+      return true
+    }
+  }
+
+  // Filter out `thread-loader` from the `use` array.
+  // Mitigate https://github.com/vuejs/vue/issues/12828
+  // Note this won't work if the `use` filed is a function
+  if (Array.isArray(res.use)) {
+    const isThreadLoader = (loader) => loader === 'thread-loader' || /\/node_modules\/thread-loader\//.test(loader)
+
+    res.use = res.use.filter(useEntry => {
+      const loader = typeof useEntry === 'string' ? useEntry : useEntry.loader
+      return !isThreadLoader(loader)
+    })
+  }
+
+  if (rule.rules) {
+    res.rules = rule.rules.map(cloneRuleForRenderFn)
+  }
+
+  if (rule.oneOf) {
+    res.oneOf = rule.oneOf.map(cloneRuleForRenderFn)
+  }
+
+  return res
+}
+
+VueLoaderPlugin.NS = NS
+module.exports = VueLoaderPlugin

app_vue/node_modules/@vue/vue-loader-v15/lib/plugin-webpack5.js

@@ -0,0 +1,334 @@
+const { resolveCompiler } = require('./compiler')
+
+const qs = require('querystring')
+const id = 'vue-loader-plugin'
+const NS = 'vue-loader'
+const BasicEffectRulePlugin = require('webpack/lib/rules/BasicEffectRulePlugin')
+const BasicMatcherRulePlugin = require('webpack/lib/rules/BasicMatcherRulePlugin')
+const RuleSetCompiler = require('webpack/lib/rules/RuleSetCompiler')
+const UseEffectRulePlugin = require('webpack/lib/rules/UseEffectRulePlugin')
+
+const objectMatcherRulePlugins = []
+try {
+  const ObjectMatcherRulePlugin = require('webpack/lib/rules/ObjectMatcherRulePlugin')
+  objectMatcherRulePlugins.push(
+    new ObjectMatcherRulePlugin('assert', 'assertions'),
+    new ObjectMatcherRulePlugin('descriptionData')
+  )
+} catch (e) {
+  const DescriptionDataMatcherRulePlugin = require('webpack/lib/rules/DescriptionDataMatcherRulePlugin')
+  objectMatcherRulePlugins.push(new DescriptionDataMatcherRulePlugin())
+}
+
+const ruleSetCompiler = new RuleSetCompiler([
+  new BasicMatcherRulePlugin('test', 'resource'),
+  new BasicMatcherRulePlugin('mimetype'),
+  new BasicMatcherRulePlugin('dependency'),
+  new BasicMatcherRulePlugin('include', 'resource'),
+  new BasicMatcherRulePlugin('exclude', 'resource', true),
+  new BasicMatcherRulePlugin('conditions'),
+  new BasicMatcherRulePlugin('resource'),
+  new BasicMatcherRulePlugin('resourceQuery'),
+  new BasicMatcherRulePlugin('resourceFragment'),
+  new BasicMatcherRulePlugin('realResource'),
+  new BasicMatcherRulePlugin('issuer'),
+  new BasicMatcherRulePlugin('compiler'),
+  ...objectMatcherRulePlugins,
+  new BasicEffectRulePlugin('type'),
+  new BasicEffectRulePlugin('sideEffects'),
+  new BasicEffectRulePlugin('parser'),
+  new BasicEffectRulePlugin('resolve'),
+  new BasicEffectRulePlugin('generator'),
+  new UseEffectRulePlugin()
+])
+
+class VueLoaderPlugin {
+  apply(compiler) {
+    const normalModule = compiler.webpack
+      ? compiler.webpack.NormalModule
+      : require('webpack/lib/NormalModule')
+    // add NS marker so that the loader can detect and report missing plugin
+    compiler.hooks.compilation.tap(id, (compilation) => {
+      const normalModuleLoader =
+        normalModule.getCompilationHooks(compilation).loader
+      normalModuleLoader.tap(id, (loaderContext) => {
+        loaderContext[NS] = true
+      })
+    })
+
+    const rules = compiler.options.module.rules
+    let rawVueRule
+    let vueRules = []
+
+    for (const rawRule of rules) {
+      // skip rules with 'enforce'. eg. rule for eslint-loader
+      if (rawRule.enforce) {
+        continue
+      }
+      vueRules = match(rawRule, 'foo.vue')
+      if (!vueRules.length) {
+        vueRules = match(rawRule, 'foo.vue.html')
+      }
+      if (vueRules.length > 0) {
+        if (rawRule.oneOf) {
+          throw new Error(
+            `[VueLoaderPlugin Error] vue-loader 15 currently does not support vue rules with oneOf.`
+          )
+        }
+        rawVueRule = rawRule
+        break
+      }
+    }
+    if (!vueRules.length) {
+      throw new Error(
+        `[VueLoaderPlugin Error] No matching rule for .vue files found.\n` +
+          `Make sure there is at least one root-level rule that matches .vue or .vue.html files.`
+      )
+    }
+
+    // get the normalized "use" for vue files
+    const vueUse = vueRules
+      .filter((rule) => rule.type === 'use')
+      .map((rule) => rule.value)
+
+    // get vue-loader options
+    const vueLoaderUseIndex = vueUse.findIndex((u) => {
+      return /^vue-loader|(\/|\\|@)vue-loader/.test(u.loader)
+    })
+
+    if (vueLoaderUseIndex < 0) {
+      throw new Error(
+        `[VueLoaderPlugin Error] No matching use for vue-loader is found.\n` +
+          `Make sure the rule matching .vue files include vue-loader in its use.`
+      )
+    }
+
+    // make sure vue-loader options has a known ident so that we can share
+    // options by reference in the template-loader by using a ref query like
+    // template-loader??vue-loader-options
+    const vueLoaderUse = vueUse[vueLoaderUseIndex]
+    vueLoaderUse.ident = 'vue-loader-options'
+    vueLoaderUse.options = vueLoaderUse.options || {}
+    const enableInlineMatchResource =
+      vueLoaderUse.options.experimentalInlineMatchResource
+
+    // for each user rule (expect the vue rule), create a cloned rule
+    // that targets the corresponding language blocks in *.vue files.
+    const refs = new Map()
+    const clonedRules = rules
+      .filter((r) => r !== rawVueRule)
+      .map((rawRule) =>
+        cloneRule(rawRule, refs, langBlockRuleCheck, langBlockRuleResource)
+      )
+
+    // fix conflict with config.loader and config.options when using config.use
+    delete rawVueRule.loader
+    delete rawVueRule.options
+    rawVueRule.use = vueUse
+
+    // rule for template compiler
+    const templateCompilerRule = {
+      loader: require.resolve('./loaders/templateLoader'),
+      resourceQuery: (query) => {
+        if (!query) {
+          return false
+        }
+        const parsed = qs.parse(query.slice(1))
+        return parsed.vue != null && parsed.type === 'template'
+      },
+      options: vueLoaderUse.options
+    }
+
+    // for each rule that matches plain .js files, also create a clone and
+    // match it against the compiled template code inside *.vue files, so that
+    // compiled vue render functions receive the same treatment as user code
+    // (mostly babel)
+    const { is27 } = resolveCompiler(compiler.options.context)
+    let jsRulesForRenderFn = []
+    if (is27) {
+      const skipThreadLoader = true
+      jsRulesForRenderFn = rules
+        .filter(
+          (r) =>
+            r !== rawVueRule &&
+            (match(r, 'test.js').length > 0 || match(r, 'test.ts').length > 0)
+        )
+        .map((rawRule) => cloneRule(rawRule, refs, jsRuleCheck, jsRuleResource, skipThreadLoader))
+    }
+
+    // global pitcher (responsible for injecting template compiler loader & CSS
+    // post loader)
+    const pitcher = {
+      loader: require.resolve('./loaders/pitcher'),
+      resourceQuery: (query) => {
+        if (!query) {
+          return false
+        }
+        const parsed = qs.parse(query.slice(1))
+        return parsed.vue != null
+      },
+      options: vueLoaderUse.options
+    }
+    // replace original rules
+    if (enableInlineMatchResource) {
+      // Match rules using `vue-loader`
+      const vueLoaderRules = rules.filter((rule) => {
+        const matchOnce = (use) => {
+          let loaderString = ''
+
+          if (!use) {
+            return loaderString
+          }
+
+          if (typeof use === 'string') {
+            loaderString = use
+          } else if (Array.isArray(use)) {
+            loaderString = matchOnce(use[0])
+          } else if (typeof use === 'object' && use.loader) {
+            loaderString = use.loader
+          }
+          return loaderString
+        }
+
+        const loader = rule.loader || matchOnce(rule.use)
+        return (
+          loader === require('../package.json').name ||
+          loader.startsWith(require.resolve('./index'))
+        )
+      })
+
+      compiler.options.module.rules = [
+        pitcher,
+        ...rules.filter((rule) => !vueLoaderRules.includes(rule)),
+        ...(is27 ? [templateCompilerRule] : []),
+        ...clonedRules,
+        ...vueLoaderRules
+      ]
+    } else {
+      compiler.options.module.rules = [
+        pitcher,
+        ...jsRulesForRenderFn,
+        ...(is27 ? [templateCompilerRule] : []),
+        ...clonedRules,
+        ...rules
+      ]
+    }
+  }
+}
+
+const matcherCache = new WeakMap()
+
+function match(rule, fakeFile) {
+  let ruleSet = matcherCache.get(rule)
+  if (!ruleSet) {
+    // skip the `include` check when locating the vue rule
+    const clonedRawRule = { ...rule }
+    delete clonedRawRule.include
+
+    ruleSet = ruleSetCompiler.compile([clonedRawRule])
+    matcherCache.set(rule, ruleSet)
+  }
+
+  return ruleSet.exec({
+    resource: fakeFile
+  })
+}
+
+const langBlockRuleCheck = (query, rule) => {
+  return (
+    query.type === 'custom' || !rule.conditions.length || query.lang != null
+  )
+}
+
+const langBlockRuleResource = (query, resource) => `${resource}.${query.lang}`
+
+const jsRuleCheck = (query) => {
+  return query.type === 'template'
+}
+
+const jsRuleResource = (query, resource) =>
+  `${resource}.${query.ts ? `ts` : `js`}`
+
+let uid = 0
+
+function cloneRule(rawRule, refs, ruleCheck, ruleResource, skipThreadLoader) {
+  const compiledRule = ruleSetCompiler.compileRule(
+    `clonedRuleSet-${++uid}`,
+    rawRule,
+    refs
+  )
+
+  // do not process rule with enforce
+  if (!rawRule.enforce) {
+    const ruleUse = compiledRule.effects
+      .filter((effect) => effect.type === 'use')
+      .map((effect) => effect.value)
+    // fix conflict with config.loader and config.options when using config.use
+    delete rawRule.loader
+    delete rawRule.options
+
+    // Filter out `thread-loader` from the `use` array.
+    // Mitigate https://github.com/vuejs/vue/issues/12828
+    // Note this won't work if the `use` filed is a function
+    if (skipThreadLoader && Array.isArray(ruleUse)) {
+      const isThreadLoader = (loader) => loader === 'thread-loader' || /\/node_modules\/thread-loader\//.test(loader)
+      rawRule.use = ruleUse.filter(useEntry => {
+        const loader = typeof useEntry === 'string' ? useEntry : useEntry.loader
+        return !isThreadLoader(loader)
+      })
+    } else {
+      rawRule.use = ruleUse
+    }
+  }
+
+  let currentResource
+  const res = {
+    ...rawRule,
+    resource: (resources) => {
+      currentResource = resources
+      return true
+    },
+    resourceQuery: (query) => {
+      if (!query) {
+        return false
+      }
+
+      const parsed = qs.parse(query.slice(1))
+      if (parsed.vue == null) {
+        return false
+      }
+      if (!ruleCheck(parsed, compiledRule)) {
+        return false
+      }
+      const fakeResourcePath = ruleResource(parsed, currentResource)
+      for (const condition of compiledRule.conditions) {
+        // add support for resourceQuery
+        const request =
+          condition.property === 'resourceQuery' ? query : fakeResourcePath
+        if (condition && !condition.fn(request)) {
+          return false
+        }
+      }
+      return true
+    }
+  }
+
+  delete res.test
+
+  if (rawRule.rules) {
+    res.rules = rawRule.rules.map((rule) =>
+      cloneRule(rule, refs, ruleCheck, ruleResource)
+    )
+  }
+
+  if (rawRule.oneOf) {
+    res.oneOf = rawRule.oneOf.map((rule) =>
+      cloneRule(rule, refs, ruleCheck, ruleResource)
+    )
+  }
+
+  return res
+}
+
+VueLoaderPlugin.NS = NS
+module.exports = VueLoaderPlugin

app_vue/node_modules/@vue/vue-loader-v15/lib/plugin.js

@@ -0,0 +1,17 @@
+const { testWebpack5 } = require('./codegen/utils')
+const NS = 'vue-loader'
+class VueLoaderPlugin {
+  apply(compiler) {
+    let Ctor = null
+    if (testWebpack5(compiler)) {
+      // webpack5 and upper
+      Ctor = require('./plugin-webpack5')
+    } else {
+      // webpack4 and lower
+      Ctor = require('./plugin-webpack4')
+    }
+    new Ctor().apply(compiler)
+  }
+}
+VueLoaderPlugin.NS = NS
+module.exports = VueLoaderPlugin

app_vue/node_modules/@vue/vue-loader-v15/lib/resolveScript.js

@@ -0,0 +1,51 @@
+const { resolveCompiler } = require('./compiler')
+
+const clientCache = new WeakMap()
+const serverCache = new WeakMap()
+
+exports.resolveScript = function resolveScript(
+  descriptor,
+  scopeId,
+  options,
+  loaderContext
+) {
+  if (!descriptor.script && !descriptor.scriptSetup) {
+    return null
+  }
+
+  const { compiler } = resolveCompiler(loaderContext.rootContext, loaderContext)
+  if (!compiler.compileScript) {
+    if (descriptor.scriptSetup) {
+      loaderContext.emitError(
+        'The version of Vue you are using does not support <script setup>. ' +
+          'Please upgrade to 2.7 or above.'
+      )
+    }
+    return descriptor.script
+  }
+
+  const isProd =
+    loaderContext.mode === 'production' || process.env.NODE_ENV === 'production'
+  const isServer = options.optimizeSSR || loaderContext.target === 'node'
+
+  const cacheToUse = isServer ? serverCache : clientCache
+  const cached = cacheToUse.get(descriptor)
+  if (cached) {
+    return cached
+  }
+
+  let resolved = null
+
+  try {
+    resolved = compiler.compileScript(descriptor, {
+      id: scopeId,
+      isProd,
+      babelParserPlugins: options.babelParserPlugins
+    })
+  } catch (e) {
+    loaderContext.emitError(e)
+  }
+
+  cacheToUse.set(descriptor, resolved)
+  return resolved
+}

app_vue/node_modules/@vue/vue-loader-v15/lib/runtime/componentNormalizer.js

@@ -0,0 +1,96 @@
+/* globals __VUE_SSR_CONTEXT__ */
+
+// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).
+// This module is a runtime utility for cleaner component module output and will
+// be included in the final webpack user bundle.
+
+export default function normalizeComponent(
+  scriptExports,
+  render,
+  staticRenderFns,
+  functionalTemplate,
+  injectStyles,
+  scopeId,
+  moduleIdentifier /* server only */,
+  shadowMode /* vue-cli only */
+) {
+  // Vue.extend constructor export interop
+  var options =
+    typeof scriptExports === 'function' ? scriptExports.options : scriptExports
+
+  // render functions
+  if (render) {
+    options.render = render
+    options.staticRenderFns = staticRenderFns
+    options._compiled = true
+  }
+
+  // functional template
+  if (functionalTemplate) {
+    options.functional = true
+  }
+
+  // scopedId
+  if (scopeId) {
+    options._scopeId = 'data-v-' + scopeId
+  }
+
+  var hook
+  if (moduleIdentifier) {
+    // server build
+    hook = function (context) {
+      // 2.3 injection
+      context =
+        context || // cached call
+        (this.$vnode && this.$vnode.ssrContext) || // stateful
+        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
+      // 2.2 with runInNewContext: true
+      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
+        context = __VUE_SSR_CONTEXT__
+      }
+      // inject component styles
+      if (injectStyles) {
+        injectStyles.call(this, context)
+      }
+      // register component module identifier for async chunk inferrence
+      if (context && context._registeredComponents) {
+        context._registeredComponents.add(moduleIdentifier)
+      }
+    }
+    // used by ssr in case component is cached and beforeCreate
+    // never gets called
+    options._ssrRegister = hook
+  } else if (injectStyles) {
+    hook = shadowMode
+      ? function () {
+          injectStyles.call(
+            this,
+            (options.functional ? this.parent : this).$root.$options.shadowRoot
+          )
+        }
+      : injectStyles
+  }
+
+  if (hook) {
+    if (options.functional) {
+      // for template-only hot-reload because in that case the render fn doesn't
+      // go through the normalizer
+      options._injectStyles = hook
+      // register for functional component in vue file
+      var originalRender = options.render
+      options.render = function renderWithStyleInjection(h, context) {
+        hook.call(context)
+        return originalRender(h, context)
+      }
+    } else {
+      // inject component registration as beforeCreate hook
+      var existing = options.beforeCreate
+      options.beforeCreate = existing ? [].concat(existing, hook) : [hook]
+    }
+  }
+
+  return {
+    exports: scriptExports,
+    options: options
+  }
+}

app_vue/node_modules/@vue/vue-loader-v15/lib/select.js

@@ -0,0 +1,50 @@
+const { resolveScript } = require('./resolveScript')
+
+module.exports = function selectBlock(
+  descriptor,
+  scopeId,
+  options,
+  loaderContext,
+  query,
+  appendExtension
+) {
+  // template
+  if (query.type === `template`) {
+    if (appendExtension) {
+      loaderContext.resourcePath += '.' + (descriptor.template.lang || 'html')
+    }
+    loaderContext.callback(
+      null,
+      descriptor.template.content,
+      descriptor.template.map
+    )
+    return
+  }
+
+  // script
+  if (query.type === `script`) {
+    const script = resolveScript(descriptor, scopeId, options, loaderContext)
+    if (appendExtension) {
+      loaderContext.resourcePath += '.' + (script.lang || 'js')
+    }
+    loaderContext.callback(null, script.content, script.map)
+    return
+  }
+
+  // styles
+  if (query.type === `style` && query.index != null) {
+    const style = descriptor.styles[query.index]
+    if (appendExtension) {
+      loaderContext.resourcePath += '.' + (style.lang || 'css')
+    }
+    loaderContext.callback(null, style.content, style.map)
+    return
+  }
+
+  // custom
+  if (query.type === 'custom' && query.index != null) {
+    const block = descriptor.customBlocks[query.index]
+    loaderContext.callback(null, block.content, block.map)
+    return
+  }
+}