svelte-on-rails 0.0.1

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/transformers/postcss.js

@@ -0,0 +1,84 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformer = void 0;
+const postcss_1 = __importDefault(require("postcss"));
+async function process({ options: { plugins = [], parser, syntax } = {}, content, filename, sourceMap, }) {
+    const { css, map, messages } = await (0, postcss_1.default)(plugins).process(content, {
+        from: filename,
+        to: filename,
+        map: { prev: sourceMap, inline: false },
+        parser,
+        syntax,
+    });
+    const dependencies = messages.reduce((acc, msg) => {
+        // istanbul ignore if
+        if (msg.type !== 'dependency')
+            return acc;
+        acc.push(msg.file);
+        return acc;
+    }, []);
+    return { code: css, map, dependencies };
+}
+async function getConfigFromFile(options) {
+    try {
+        /** If not, look for a postcss config file */
+        const { default: postcssLoadConfig } = await Promise.resolve().then(() => __importStar(require(`postcss-load-config`)));
+        const loadedConfig = await postcssLoadConfig(options, options === null || options === void 0 ? void 0 : options.configFilePath);
+        return {
+            error: null,
+            config: {
+                plugins: loadedConfig.plugins,
+                // `postcss-load-config` puts all other props in a `options` object
+                ...loadedConfig.options,
+            },
+        };
+    }
+    catch (e) {
+        return {
+            config: null,
+            error: e,
+        };
+    }
+}
+/** Adapted from https://github.com/TehShrike/svelte-preprocess-postcss */
+const transformer = async ({ content, filename, options = {}, map, }) => {
+    let fileConfig = null;
+    if (!options.plugins) {
+        fileConfig = await getConfigFromFile(options);
+        options = { ...options, ...fileConfig.config };
+    }
+    if (options.plugins || options.syntax || options.parser) {
+        return process({ options, content, filename, sourceMap: map });
+    }
+    if ((fileConfig === null || fileConfig === void 0 ? void 0 : fileConfig.error) != null) {
+        console.error(`[svelte-preprocess] PostCSS configuration was not passed or is invalid. If you expect to load it from a file make sure to install "postcss-load-config" and try again.\n\n${fileConfig.error}`);
+    }
+    return { code: content, map, dependencies: [] };
+};
+exports.transformer = transformer;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/transformers/pug.d.ts

@@ -0,0 +1,3 @@
+import type { Transformer, Options } from '../types';
+declare const transformer: Transformer<Options.Pug>;
+export { transformer };

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/transformers/pug.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformer = void 0;
+const pug_1 = __importDefault(require("pug"));
+// Mixins to use svelte template features
+const GET_MIXINS = (indentationType) => `mixin if(condition)
+%_| {#if !{condition}}
+%_block
+%_| {/if}
+
+mixin else
+%_| {:else}
+%_block
+
+mixin elseif(condition)
+%_| {:else if !{condition}}
+%_block
+
+mixin key(expression)
+%_| {#key !{expression}}
+%_block
+%_| {/key}
+
+mixin each(loop)
+%_| {#each !{loop}}
+%_block
+%_| {/each}
+
+mixin await(promise)
+%_| {#await !{promise}}
+%_block
+%_| {/await}
+
+mixin then(answer)
+%_| {:then !{answer}}
+%_block
+
+mixin catch(error)
+%_| {:catch !{error}}
+%_block
+
+mixin html(expression)
+%_| {@html !{expression}}
+
+mixin const(expression)
+%_| {@const !{expression}}
+
+mixin debug(variables)
+%_| {@debug !{variables}}
+
+mixin snippet(expression)
+%_| {#snippet !{expression}}
+%_block
+%_| {/snippet}
+
+mixin render(expression)
+%_| {@render !{expression}}`.replace(/%_/g, indentationType === 'tab' ? '\t' : '  ');
+const transformer = async ({ content, filename, options, }) => {
+    var _a;
+    const pugOptions = {
+        // needed so pug doesn't mirror boolean attributes
+        // and prop spreading expressions.
+        doctype: 'html',
+        compileDebug: false,
+        filename,
+        ...options,
+    };
+    const spaces = guessIndentString(content);
+    const input = `${GET_MIXINS(spaces ? 'space' : 'tab')}\n${content}`;
+    const compiled = pug_1.default.compile(input, pugOptions);
+    let code;
+    try {
+        code = compiled();
+    }
+    catch (e) {
+        // The error message does not have much context, add more of it
+        if (e instanceof Error) {
+            e.message = `[svelte-preprocess] Pug error while preprocessing ${filename}\n\n${e.message}`;
+        }
+        throw e;
+    }
+    return {
+        code,
+        dependencies: (_a = compiled.dependencies) !== null && _a !== void 0 ? _a : [],
+    };
+};
+exports.transformer = transformer;
+// Sourced from `golden-fleece`
+// https://github.com/Rich-Harris/golden-fleece/blob/f2446f331640f325e13609ed99b74b6a45e755c2/src/patch.ts#L302
+function guessIndentString(str) {
+    const lines = str.split('\n');
+    let tabs = 0;
+    let spaces = 0;
+    let minSpaces = 8;
+    lines.forEach((line) => {
+        const match = /^(?: +|\t+)/.exec(line);
+        if (!match)
+            return;
+        const [whitespace] = match;
+        if (whitespace.length === line.length)
+            return;
+        if (whitespace[0] === '\t') {
+            tabs += 1;
+        }
+        else {
+            spaces += 1;
+            if (whitespace.length > 1 && whitespace.length < minSpaces) {
+                minSpaces = whitespace.length;
+            }
+        }
+    });
+    if (spaces > tabs) {
+        let result = '';
+        while (minSpaces--)
+            result += ' ';
+        return result.length;
+    }
+}

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/transformers/replace.d.ts

@@ -0,0 +1,3 @@
+import type { Transformer, Options } from '../types';
+declare const transformer: Transformer<Options.Replace>;
+export { transformer };

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/transformers/replace.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformer = void 0;
+const transformer = async ({ content, options, }) => {
+    let newContent = content;
+    if (options == null) {
+        return { code: content };
+    }
+    for (const [regex, replacer] of options) {
+        newContent = newContent.replace(regex, replacer);
+    }
+    return {
+        code: newContent,
+    };
+};
+exports.transformer = transformer;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/transformers/scss.d.ts

@@ -0,0 +1,3 @@
+import type { Transformer, Options } from '../types';
+declare const transformer: Transformer<Options.Sass>;
+export { transformer };

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/transformers/scss.js

@@ -0,0 +1,106 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformer = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("../modules/utils");
+const tildeImporter = (url, prev) => {
+    if (!url.startsWith('~')) {
+        return null;
+    }
+    // not sure why this ends up here, but let's remove it
+    prev = prev.replace('http://localhost', '');
+    // on windows, path comes encoded
+    if (process.platform === 'win32') {
+        prev = decodeURIComponent(prev);
+    }
+    const modulePath = path_1.default.join('node_modules', ...url.slice(1).split(/[\\/]/g));
+    const foundPath = (0, utils_1.findUp)({ what: modulePath, from: prev });
+    // istanbul ignore if
+    if (foundPath == null) {
+        return null;
+    }
+    const contents = (0, fs_1.readFileSync)(foundPath).toString();
+    return { contents };
+};
+const infoRegex = /dart-sass\s(\d+)\.(\d+)\.(\d+)/;
+const transformer = async ({ content, filename, options = {}, }) => {
+    var _a, _b;
+    const { renderSync, info } = await Promise.resolve().then(() => __importStar(require('sass')));
+    const { prependData, ...restOptions } = options;
+    const match = (_a = info.match(infoRegex)) !== null && _a !== void 0 ? _a : [0, 0, 0, 0];
+    const [_, major, minor] = match.map(Number);
+    const sassOptions = {
+        ...restOptions,
+        silenceDeprecations: major >= 1 && minor >= 79
+            ? ['legacy-js-api', ...(restOptions.silenceDeprecations || [])]
+            : restOptions.silenceDeprecations,
+        includePaths: (0, utils_1.getIncludePaths)(filename, options.includePaths),
+        sourceMap: true,
+        sourceMapEmbed: false,
+        omitSourceMapUrl: true,
+        outFile: `${filename}.css`,
+        outputStyle: 'expanded',
+        file: filename,
+        data: content,
+    };
+    if (Array.isArray(sassOptions.importer)) {
+        sassOptions.importer = [tildeImporter, ...sassOptions.importer];
+    }
+    else if (sassOptions.importer == null) {
+        sassOptions.importer = [tildeImporter];
+    }
+    else {
+        sassOptions.importer = [sassOptions.importer, tildeImporter];
+    }
+    // scss errors if passed an empty string
+    if (content.length === 0) {
+        return { code: '' };
+    }
+    const compiled = renderSync(sassOptions);
+    // We need to normalize the path for windows, because the sass compiler
+    // returns a windows path in posix format __just for the entry__ (the dependency list below is fine 🤷)
+    // More info: https://github.com/sveltejs/svelte-preprocess/issues/619
+    const normalizedEntryPath = process.platform === 'win32'
+        ? compiled.stats.entry.split('/').join(path_1.default.win32.sep)
+        : compiled.stats.entry;
+    // For some reason, scss includes the main 'file' in the array, we don't want that
+    // Unfortunately I didn't manage to reproduce this in the test env
+    // More info: https://github.com/sveltejs/svelte-preprocess/issues/346
+    const absoluteEntryPath = path_1.default.isAbsolute(normalizedEntryPath)
+        ? normalizedEntryPath
+        : path_1.default.join(process.cwd(), normalizedEntryPath);
+    const processed = {
+        code: compiled.css.toString(),
+        map: (_b = compiled.map) === null || _b === void 0 ? void 0 : _b.toString(),
+        dependencies: Array.from(compiled.stats.includedFiles).filter((filepath) => filepath !== absoluteEntryPath),
+    };
+    return processed;
+};
+exports.transformer = transformer;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/transformers/stylus.d.ts

@@ -0,0 +1,3 @@
+import type { Transformer, Options } from '../types';
+declare const transformer: Transformer<Options.Stylus>;
+export { transformer };

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/transformers/stylus.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformer = void 0;
+const path_1 = __importDefault(require("path"));
+const stylus_1 = __importDefault(require("stylus"));
+const utils_1 = require("../modules/utils");
+const transformer = ({ content, filename, options = {}, }) => {
+    options = {
+        paths: (0, utils_1.getIncludePaths)(filename, options.paths),
+        ...options,
+    };
+    return new Promise((resolve, reject) => {
+        const style = (0, stylus_1.default)(content, {
+            filename,
+            ...options,
+        }).set('sourcemap', options.sourcemap);
+        style.render((err, css) => {
+            var _a;
+            // istanbul ignore next
+            if (err)
+                reject(err);
+            if ((_a = style.sourcemap) === null || _a === void 0 ? void 0 : _a.sources) {
+                style.sourcemap.sources = style.sourcemap.sources.map((source) => path_1.default.resolve(source));
+            }
+            resolve({
+                code: css,
+                map: style.sourcemap,
+                // .map() necessary for windows compatibility
+                dependencies: style
+                    .deps(filename)
+                    .map((filePath) => path_1.default.resolve(filePath)),
+            });
+        });
+    });
+};
+exports.transformer = transformer;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/transformers/typescript.d.ts

@@ -0,0 +1,11 @@
+import ts from 'typescript';
+import type { Transformer, Options } from '../types';
+export declare function loadTsconfig(fallback: {
+    options: ts.CompilerOptions;
+    errors: ts.Diagnostic[];
+}, filename: string, tsOptions: Options.Typescript): {
+    options: ts.CompilerOptions;
+    errors: ts.Diagnostic[];
+};
+declare const transformer: Transformer<Options.Typescript>;
+export { transformer };

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/transformers/typescript.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformer = exports.loadTsconfig = void 0;
+const path_1 = require("path");
+const typescript_1 = __importDefault(require("typescript"));
+const errors_1 = require("../modules/errors");
+/**
+ * Map of valid tsconfigs (no errors). Key is the path.
+ */
+const tsconfigMap = new Map();
+function createFormatDiagnosticsHost(cwd) {
+    return {
+        getCanonicalFileName: (fileName) => fileName.replace('.injected.ts', ''),
+        getCurrentDirectory: () => cwd,
+        getNewLine: () => typescript_1.default.sys.newLine,
+    };
+}
+function formatDiagnostics(diagnostics, basePath) {
+    if (Array.isArray(diagnostics)) {
+        return typescript_1.default.formatDiagnosticsWithColorAndContext(diagnostics, createFormatDiagnosticsHost(basePath));
+    }
+    return typescript_1.default.formatDiagnostic(diagnostics, createFormatDiagnosticsHost(basePath));
+}
+let warned_verbatim = false;
+function getCompilerOptions({ filename, options, basePath, }) {
+    var _a;
+    const inputOptions = typescript_1.default.convertCompilerOptionsFromJson((_a = options.compilerOptions) !== null && _a !== void 0 ? _a : {}, basePath);
+    const { errors, options: convertedCompilerOptions } = options.tsconfigFile !== false || options.tsconfigDirectory
+        ? loadTsconfig(inputOptions, filename, options)
+        : inputOptions;
+    if (errors.length) {
+        throw new Error(formatDiagnostics(errors, basePath));
+    }
+    const compilerOptions = {
+        target: typescript_1.default.ScriptTarget.ES2015,
+        ...convertedCompilerOptions,
+        // force module(resolution) to esnext and a compatible moduleResolution. Reason:
+        // transpileModule treats NodeNext as CommonJS because it doesn't read the package.json.
+        // Also see https://github.com/microsoft/TypeScript/issues/53022 (the filename workaround doesn't work).
+        module: typescript_1.default.ModuleKind.ESNext,
+        moduleResolution: convertedCompilerOptions.moduleResolution ===
+            typescript_1.default.ModuleResolutionKind.Bundler
+            ? typescript_1.default.ModuleResolutionKind.Bundler
+            : typescript_1.default.ModuleResolutionKind.Node10,
+        customConditions: undefined, // fails when using an invalid moduleResolution combination which could happen when we force moduleResolution to Node10
+        allowNonTsExtensions: true,
+        // Clear outDir since it causes source map issues when the files aren't actually written to disk.
+        outDir: undefined,
+    };
+    if (!warned_verbatim && !compilerOptions.verbatimModuleSyntax) {
+        warned_verbatim = true;
+        console.warn('\x1b[1m%s\x1b[0m', 'The TypeScript option verbatimModuleSyntax is now required when using Svelte files with lang="ts". Please add it to your tsconfig.json.');
+        // best effort to still add it, if possible, in case no config was found whatsoever
+        if (Object.keys(inputOptions.options).length === 0 &&
+            convertedCompilerOptions === inputOptions.options) {
+            compilerOptions.verbatimModuleSyntax = true;
+        }
+    }
+    if (compilerOptions.target === typescript_1.default.ScriptTarget.ES3 ||
+        compilerOptions.target === typescript_1.default.ScriptTarget.ES5) {
+        throw new Error(`Svelte only supports es6+ syntax. Set your 'compilerOptions.target' to 'es6' or higher.`);
+    }
+    return compilerOptions;
+}
+function transpileTs({ code, fileName, basePath, options, compilerOptions, transformers, }) {
+    const { outputText: transpiledCode, sourceMapText, diagnostics, } = typescript_1.default.transpileModule(code, {
+        fileName,
+        compilerOptions,
+        reportDiagnostics: options.reportDiagnostics !== false,
+        transformers,
+    });
+    if (diagnostics && diagnostics.length > 0) {
+        // could this be handled elsewhere?
+        const hasError = diagnostics.some((d) => d.category === typescript_1.default.DiagnosticCategory.Error);
+        if (hasError) {
+            const formattedDiagnostics = formatDiagnostics(diagnostics, basePath);
+            console.log(formattedDiagnostics);
+            (0, errors_1.throwTypescriptError)();
+        }
+    }
+    return { transpiledCode, sourceMapText, diagnostics };
+}
+function loadTsconfig(fallback, filename, tsOptions) {
+    if (typeof tsOptions.tsconfigFile === 'boolean') {
+        return fallback;
+    }
+    let basePath = process.cwd();
+    const fileDirectory = (tsOptions.tsconfigDirectory ||
+        (0, path_1.dirname)(filename));
+    let tsconfigFile = tsOptions.tsconfigFile ||
+        typescript_1.default.findConfigFile(fileDirectory, typescript_1.default.sys.fileExists);
+    if (!tsconfigFile) {
+        return fallback;
+    }
+    tsconfigFile = (0, path_1.isAbsolute)(tsconfigFile)
+        ? tsconfigFile
+        : (0, path_1.join)(basePath, tsconfigFile);
+    basePath = (0, path_1.dirname)(tsconfigFile);
+    if (tsconfigMap.has(tsconfigFile)) {
+        return {
+            errors: [],
+            options: tsconfigMap.get(tsconfigFile),
+        };
+    }
+    const { error, config } = typescript_1.default.readConfigFile(tsconfigFile, typescript_1.default.sys.readFile);
+    if (error) {
+        throw new Error(formatDiagnostics(error, basePath));
+    }
+    // Do this so TS will not search for initial files which might take a while
+    config.include = [];
+    let { errors, options } = typescript_1.default.parseJsonConfigFileContent(config, typescript_1.default.sys, basePath, fallback.options, tsconfigFile);
+    // Filter out "no files found error"
+    errors = errors.filter((d) => d.code !== 18003);
+    if (errors.length === 0) {
+        tsconfigMap.set(tsconfigFile, options);
+    }
+    return { errors, options };
+}
+exports.loadTsconfig = loadTsconfig;
+let warned_mixed = false;
+const transformer = async ({ content, filename = 'input.svelte', options = {}, }) => {
+    const basePath = process.cwd();
+    filename = (0, path_1.isAbsolute)(filename) ? filename : (0, path_1.resolve)(basePath, filename);
+    const compilerOptions = getCompilerOptions({ filename, options, basePath });
+    if ('handleMixedImports' in options && !warned_mixed) {
+        warned_mixed = true;
+        console.warn('The svelte-preprocess TypeScript option handleMixedImports was removed. Use the verbatimModuleSyntax TypeScript option instead.');
+    }
+    const { transpiledCode, sourceMapText, diagnostics } = transpileTs({
+        code: content,
+        fileName: filename,
+        basePath,
+        options,
+        compilerOptions,
+    });
+    return {
+        code: transpiledCode,
+        map: sourceMapText,
+        diagnostics,
+    };
+};
+exports.transformer = transformer;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/types/index.d.ts

@@ -0,0 +1,63 @@
+/// <reference types="svelte" />
+import * as Options from './options';
+import type { Processed as SvelteProcessed, Preprocessor as SveltePreprocessor, PreprocessorGroup } from 'svelte/compiler';
+export { Options };
+export { PreprocessorGroup };
+export type PreprocessorArgs = Preprocessor extends (options: infer T) => any ? T : never;
+export type TransformerArgs<T> = {
+    content: string;
+    filename?: string;
+    attributes?: Record<string, any>;
+    map?: string | object;
+    markup?: string;
+    diagnostics?: unknown[];
+    options?: T;
+};
+/**
+ * Small extension to the official SvelteProcessed type
+ * to include possible diagnostics.
+ * Used for the typescript transformer.
+ */
+export type Processed = SvelteProcessed & {
+    diagnostics?: any[];
+};
+/**
+ * Svelte preprocessor type with guaranteed Processed results
+ *
+ * The official type also considers `void`
+ * */
+export type Preprocessor = (options: Parameters<SveltePreprocessor>[0]) => Processed | Promise<Processed>;
+export type Transformer<T> = (args: TransformerArgs<T>) => Processed | Promise<Processed>;
+export type TransformerOptions<T = any> = boolean | T | Transformer<T>;
+export interface Transformers {
+    babel?: TransformerOptions<Options.Babel>;
+    typescript?: TransformerOptions<Options.Typescript>;
+    scss?: TransformerOptions<Options.Sass>;
+    sass?: TransformerOptions<Options.Sass>;
+    less?: TransformerOptions<Options.Less>;
+    stylus?: TransformerOptions<Options.Stylus>;
+    postcss?: TransformerOptions<Options.Postcss>;
+    coffeescript?: TransformerOptions<Options.Coffeescript>;
+    pug?: TransformerOptions<Options.Pug>;
+    globalStyle?: Options.GlobalStyle;
+    replace?: Options.Replace;
+    [language: string]: TransformerOptions;
+}
+export type AutoPreprocessGroup = PreprocessorGroup;
+export type AutoPreprocessOptions = {
+    markupTagName?: string;
+    aliases?: Array<[string, string]>;
+    sourceMap?: boolean;
+    babel?: TransformerOptions<Options.Babel>;
+    typescript?: TransformerOptions<Options.Typescript>;
+    scss?: TransformerOptions<Options.Sass>;
+    sass?: TransformerOptions<Options.Sass>;
+    less?: TransformerOptions<Options.Less>;
+    stylus?: TransformerOptions<Options.Stylus>;
+    postcss?: TransformerOptions<Options.Postcss>;
+    coffeescript?: TransformerOptions<Options.Coffeescript>;
+    pug?: TransformerOptions<Options.Pug>;
+    globalStyle?: Options.GlobalStyle | boolean;
+    replace?: Options.Replace;
+    [languageName: string]: TransformerOptions;
+};

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/types/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Options = void 0;
+const Options = __importStar(require("./options"));
+exports.Options = Options;