svelte-on-rails 0.0.1

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

@@ -0,0 +1,15 @@
+import { sveltePreprocess } from './autoProcess';
+/** @deprecated Use the named export instead: `import { sveltePreprocess } from 'svelte-preprocess'` */
+declare const _default: typeof sveltePreprocess;
+export default _default;
+export { sveltePreprocess } from './autoProcess';
+export { pug } from './processors/pug';
+export { coffeescript } from './processors/coffeescript';
+export { typescript } from './processors/typescript';
+export { less } from './processors/less';
+export { scss, sass } from './processors/scss';
+export { stylus } from './processors/stylus';
+export { postcss } from './processors/postcss';
+export { globalStyle } from './processors/globalStyle';
+export { babel } from './processors/babel';
+export { replace } from './processors/replace';

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replace = exports.babel = exports.globalStyle = exports.postcss = exports.stylus = exports.sass = exports.scss = exports.less = exports.typescript = exports.coffeescript = exports.pug = exports.sveltePreprocess = void 0;
+const autoProcess_1 = require("./autoProcess");
+// default auto processor
+// crazy es6/cjs export mix for backward compatibility
+/** @deprecated Use the named export instead: `import { sveltePreprocess } from 'svelte-preprocess'` */
+// eslint-disable-next-line no-multi-assign
+exports.default = exports = module.exports = autoProcess_1.sveltePreprocess;
+// also export auto preprocessor as named export to sidestep default export type issues with "module": "NodeNext" in tsconfig.
+// Don't just do export { sveltePreprocess } because the transpiled output is wrong then.
+var autoProcess_2 = require("./autoProcess");
+Object.defineProperty(exports, "sveltePreprocess", { enumerable: true, get: function () { return autoProcess_2.sveltePreprocess; } });
+// stand-alone processors to be included manually, use their named exports for better transpilation or else node will not detect the named exports properly
+var pug_1 = require("./processors/pug");
+Object.defineProperty(exports, "pug", { enumerable: true, get: function () { return pug_1.pug; } });
+var coffeescript_1 = require("./processors/coffeescript");
+Object.defineProperty(exports, "coffeescript", { enumerable: true, get: function () { return coffeescript_1.coffeescript; } });
+var typescript_1 = require("./processors/typescript");
+Object.defineProperty(exports, "typescript", { enumerable: true, get: function () { return typescript_1.typescript; } });
+var less_1 = require("./processors/less");
+Object.defineProperty(exports, "less", { enumerable: true, get: function () { return less_1.less; } });
+var scss_1 = require("./processors/scss");
+Object.defineProperty(exports, "scss", { enumerable: true, get: function () { return scss_1.scss; } });
+Object.defineProperty(exports, "sass", { enumerable: true, get: function () { return scss_1.sass; } });
+var stylus_1 = require("./processors/stylus");
+Object.defineProperty(exports, "stylus", { enumerable: true, get: function () { return stylus_1.stylus; } });
+var postcss_1 = require("./processors/postcss");
+Object.defineProperty(exports, "postcss", { enumerable: true, get: function () { return postcss_1.postcss; } });
+var globalStyle_1 = require("./processors/globalStyle");
+Object.defineProperty(exports, "globalStyle", { enumerable: true, get: function () { return globalStyle_1.globalStyle; } });
+var babel_1 = require("./processors/babel");
+Object.defineProperty(exports, "babel", { enumerable: true, get: function () { return babel_1.babel; } });
+var replace_1 = require("./processors/replace");
+Object.defineProperty(exports, "replace", { enumerable: true, get: function () { return replace_1.replace; } });

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/modules/errors.d.ts

@@ -0,0 +1,2 @@
+export declare const throwError: (msg: string) => never;
+export declare const throwTypescriptError: () => void;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/modules/errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwTypescriptError = exports.throwError = void 0;
+const throwError = (msg) => {
+    throw new Error(`[svelte-preprocess] ${msg}`);
+};
+exports.throwError = throwError;
+const throwTypescriptError = () => {
+    (0, exports.throwError)(`Encountered type error`);
+};
+exports.throwTypescriptError = throwTypescriptError;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/modules/globalifySelector.d.ts

@@ -0,0 +1 @@
+export declare function globalifySelector(selector: string): string;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/modules/globalifySelector.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalifySelector = void 0;
+/* eslint-disable line-comment-position */
+/*
+ * Split a selector string (ex: div > foo ~ .potato) by
+ * separators: space, >, +, ~ and comma (maybe not needed)
+ * We use a negative lookbehind assertion to prevent matching
+ * escaped combinators like `\~`.
+ */
+// TODO: maybe replace this ugly pattern with an actual selector parser? (https://github.com/leaverou/parsel, 2kb)
+const combinatorPattern = /(?<!\\)(?:\\\\)*([ >+~,]\s*)(?![^(]*\))(?![^[]+\]|\d)/g;
+function globalifySelector(selector) {
+    const parts = selector.trim().split(combinatorPattern);
+    const newSelector = [];
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        // if this is a separator or a :global
+        if (i % 2 !== 0 || part === '' || part.startsWith(':global')) {
+            newSelector.push(part);
+            continue;
+        }
+        // :local() with scope
+        if (part.startsWith(':local(')) {
+            newSelector.push(part.replace(/:local\((.+?)\)/g, '$1'));
+            continue;
+        }
+        // :local inlined in a selector
+        if (part.startsWith(':local')) {
+            // + 2 to ignore the :local and space combinator
+            const startIndex = i + 2;
+            let endIndex = parts.findIndex((p, idx) => idx > startIndex && p.startsWith(':global'));
+            endIndex = endIndex === -1 ? parts.length - 1 : endIndex;
+            newSelector.push(...parts.slice(startIndex, endIndex + 1));
+            i = endIndex;
+            continue;
+        }
+        newSelector.push(`:global(${part})`);
+    }
+    return newSelector.join('');
+}
+exports.globalifySelector = globalifySelector;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/modules/language.d.ts

@@ -0,0 +1,11 @@
+import type { PreprocessorArgs } from '../types';
+export declare const ALIAS_MAP: Map<string, string>;
+export declare const SOURCE_MAP_PROP_MAP: Record<string, [string[], any]>;
+export declare function getLanguageDefaults(lang?: string | null): null | Record<string, any>;
+export declare function addLanguageAlias(entries: Array<[string, string]>): void;
+export declare function getLanguageFromAlias(alias?: string | null): string | null | undefined;
+export declare function isAliasOf(alias?: string | null, lang?: string | null): boolean;
+export declare const getLanguage: (attributes: PreprocessorArgs['attributes']) => {
+    lang: string | null | undefined;
+    alias: string | null;
+};

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/modules/language.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLanguage = exports.isAliasOf = exports.getLanguageFromAlias = exports.addLanguageAlias = exports.getLanguageDefaults = exports.SOURCE_MAP_PROP_MAP = exports.ALIAS_MAP = void 0;
+const path_1 = require("path");
+const utils_1 = require("./utils");
+const LANGUAGE_DEFAULTS = {
+    sass: {
+        indentedSyntax: true,
+        stripIndent: true,
+    },
+    pug: {
+        stripIndent: true,
+    },
+    coffeescript: {
+        stripIndent: true,
+    },
+    stylus: {
+        stripIndent: true,
+    },
+    // We need to defer this require to make sugarss an optional dependency.
+    sugarss: () => ({
+        stripIndent: true,
+        // eslint-disable-next-line @typescript-eslint/no-require-imports, node/global-require
+        parser: require('sugarss'),
+    }),
+};
+exports.ALIAS_MAP = new Map([
+    ['pcss', 'css'],
+    ['postcss', 'css'],
+    ['sugarss', 'css'],
+    ['sss', 'css'],
+    ['sass', 'scss'],
+    ['styl', 'stylus'],
+    ['js', 'javascript'],
+    ['coffee', 'coffeescript'],
+    ['ts', 'typescript'],
+]);
+exports.SOURCE_MAP_PROP_MAP = {
+    babel: [['sourceMaps'], true],
+    typescript: [['compilerOptions', 'sourceMap'], true],
+    scss: [['sourceMap'], true],
+    less: [['sourceMap'], {}],
+    stylus: [['sourcemap'], true],
+    postcss: [['map'], true],
+    coffeescript: [['sourceMap'], true],
+    globalStyle: [['sourceMap'], true],
+};
+function getLanguageDefaults(lang) {
+    if (lang == null)
+        return null;
+    const defaults = LANGUAGE_DEFAULTS[lang];
+    if (!defaults)
+        return null;
+    if (typeof defaults === 'function') {
+        return defaults();
+    }
+    return defaults;
+}
+exports.getLanguageDefaults = getLanguageDefaults;
+function addLanguageAlias(entries) {
+    return entries.forEach((entry) => exports.ALIAS_MAP.set(...entry));
+}
+exports.addLanguageAlias = addLanguageAlias;
+function getLanguageFromAlias(alias) {
+    var _a;
+    return alias == null ? alias : (_a = exports.ALIAS_MAP.get(alias)) !== null && _a !== void 0 ? _a : alias;
+}
+exports.getLanguageFromAlias = getLanguageFromAlias;
+function isAliasOf(alias, lang) {
+    return lang !== alias && getLanguageFromAlias(alias) === lang;
+}
+exports.isAliasOf = isAliasOf;
+const getLanguage = (attributes) => {
+    let alias = null;
+    if (attributes.lang) {
+        // istanbul ignore if
+        if (typeof attributes.lang !== 'string') {
+            throw new Error('lang attribute must be string');
+        }
+        alias = attributes.lang;
+    }
+    else if (typeof attributes.src === 'string' &&
+        (0, utils_1.isValidLocalPath)(attributes.src)) {
+        const parts = (0, path_1.basename)(attributes.src).split('.');
+        if (parts.length > 1) {
+            alias = parts.pop();
+        }
+    }
+    return {
+        lang: getLanguageFromAlias(alias),
+        alias,
+    };
+};
+exports.getLanguage = getLanguage;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/modules/markup.d.ts

@@ -0,0 +1,9 @@
+import type { Transformer, Preprocessor } from '../types';
+/** Create a tag matching regexp. */
+export declare function createTagRegex(tagName: string, flags?: string): RegExp;
+/** Transform an attribute string into a key-value object */
+export declare function parseAttributes(attributesStr: string): Record<string, any>;
+export declare function transformMarkup({ content, filename }: {
+    content: string;
+    filename?: string;
+}, transformer: Preprocessor | Transformer<unknown>, options?: Record<string, any>): Promise<import("../types").Processed>;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/modules/markup.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformMarkup = exports.parseAttributes = exports.createTagRegex = void 0;
+/** Create a tag matching regexp. */
+function createTagRegex(tagName, flags) {
+    return new RegExp(`/<!--[^]*?-->|<${tagName}(\\s[^]*?)?(?:>([^]*?)<\\/${tagName}>|\\/>)`, flags);
+}
+exports.createTagRegex = createTagRegex;
+/** Transform an attribute string into a key-value object */
+function parseAttributes(attributesStr) {
+    return attributesStr
+        .split(/\s+/)
+        .filter(Boolean)
+        .reduce((acc, attr) => {
+        const [name, value] = attr.split('=');
+        // istanbul ignore next
+        acc[name] = value ? value.replace(/['"]/g, '') : true;
+        return acc;
+    }, {});
+}
+exports.parseAttributes = parseAttributes;
+async function transformMarkup({ content, filename }, transformer, options = {}) {
+    let { markupTagName = 'template' } = options;
+    markupTagName = markupTagName.toLocaleLowerCase();
+    const markupPattern = createTagRegex(markupTagName);
+    const templateMatch = content.match(markupPattern);
+    /** If no <template> was found, run the transformer over the whole thing */
+    if (!templateMatch || templateMatch.index == null) {
+        return transformer({
+            content,
+            markup: content,
+            attributes: {},
+            filename,
+            options,
+        });
+    }
+    const [fullMatch, attributesStr = '', templateCode] = templateMatch;
+    const attributes = parseAttributes(attributesStr);
+    /** Transform the found template code */
+    let { code, map, dependencies } = await transformer({
+        content: templateCode,
+        markup: templateCode,
+        attributes,
+        filename,
+        options,
+    });
+    code =
+        content.slice(0, templateMatch.index) +
+            code +
+            content.slice(templateMatch.index + fullMatch.length);
+    return { code, map, dependencies };
+}
+exports.transformMarkup = transformMarkup;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/modules/prepareContent.d.ts

@@ -0,0 +1,4 @@
+export declare function prepareContent({ options, content, }: {
+    options: any;
+    content: string;
+}): string;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/modules/prepareContent.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareContent = void 0;
+// todo: could use magic-string and generate some sourcemaps 🗺
+function prepareContent({ options, content, }) {
+    if (typeof options !== 'object') {
+        return content;
+    }
+    if (options.stripIndent) {
+        content = stripIndent(content);
+    }
+    if (options.prependData) {
+        content = `${options.prependData}\n${content}`;
+    }
+    return content;
+}
+exports.prepareContent = prepareContent;
+/** Get the shortest leading whitespace from lines in a string */
+function minIndent(s) {
+    const match = s.match(/^[ \t]*(?=\S)/gm);
+    if (!match) {
+        return 0;
+    }
+    return match.reduce((r, a) => Math.min(r, a.length), Infinity);
+}
+/** Strip leading whitespace from each line in a string */
+function stripIndent(s) {
+    const indent = minIndent(s);
+    if (indent === 0) {
+        return s;
+    }
+    const regex = new RegExp(`^[ \\t]{${indent}}`, 'gm');
+    return s.replace(regex, '');
+}

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/modules/tagInfo.d.ts

@@ -0,0 +1,10 @@
+import type { PreprocessorArgs } from '../types';
+export declare const getTagInfo: ({ attributes, filename, content, markup, }: PreprocessorArgs) => Promise<{
+    filename: string | undefined;
+    attributes: Record<string, string | boolean>;
+    content: string;
+    lang: string | null | undefined;
+    alias: string | null;
+    dependencies: string[];
+    markup: string;
+}>;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/modules/tagInfo.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTagInfo = void 0;
+/* eslint-disable node/prefer-promises/fs */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const language_1 = require("./language");
+const utils_1 = require("./utils");
+const resolveSrc = (importerFile, srcPath) => (0, path_1.resolve)((0, path_1.dirname)(importerFile), srcPath);
+const getSrcContent = (file) => {
+    return new Promise((resolve, reject) => {
+        (0, fs_1.readFile)(file, (error, data) => {
+            // istanbul ignore if
+            if (error)
+                reject(error);
+            else
+                resolve(data.toString());
+        });
+    });
+};
+async function doesFileExist(file) {
+    return new Promise((resolve) => (0, fs_1.access)(file, 0, (err) => resolve(!err)));
+}
+const getTagInfo = async ({ attributes, filename, content, markup, }) => {
+    const dependencies = [];
+    // catches empty content and self-closing tags
+    const isEmptyContent = content == null || content.trim().length === 0;
+    /** only include src file if content of tag is empty */
+    if (attributes.src && isEmptyContent) {
+        // istanbul ignore if
+        if (typeof attributes.src !== 'string') {
+            throw new Error('src attribute must be string');
+        }
+        let path = attributes.src;
+        /** Only try to get local files (path starts with ./ or ../) */
+        if ((0, utils_1.isValidLocalPath)(path) && filename) {
+            path = resolveSrc(filename, path);
+            if (await doesFileExist(path)) {
+                content = await getSrcContent(path);
+                dependencies.push(path);
+            }
+            else {
+                console.warn(`[svelte-preprocess] The file  "${path}" was not found.`);
+            }
+        }
+    }
+    const { lang, alias } = (0, language_1.getLanguage)(attributes);
+    return {
+        filename,
+        attributes,
+        content,
+        lang,
+        alias,
+        dependencies,
+        markup,
+    };
+};
+exports.getTagInfo = getTagInfo;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/modules/utils.d.ts

@@ -0,0 +1,17 @@
+export declare function concat(...arrs: any[]): any[];
+/** Paths used by preprocessors to resolve @imports */
+export declare function getIncludePaths(fromFilename?: string, base?: string[]): string[];
+/**
+ * Checks if a package is installed.
+ *
+ * @export
+ * @param {string} dep
+ * @returns boolean
+ */
+export declare function hasDepInstalled(dep: string): Promise<boolean>;
+export declare function isValidLocalPath(path: string): boolean;
+export declare function findUp({ what, from }: {
+    what: string;
+    from: string;
+}): string | null;
+export declare function setProp(obj: any, keyList: string[], value: any): void;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/modules/utils.js

@@ -0,0 +1,104 @@
+"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.setProp = exports.findUp = exports.isValidLocalPath = exports.hasDepInstalled = exports.getIncludePaths = exports.concat = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+function concat(...arrs) {
+    return arrs.reduce((acc, a) => {
+        if (a)
+            return acc.concat(a);
+        return acc;
+    }, []);
+}
+exports.concat = concat;
+/** Paths used by preprocessors to resolve @imports */
+function getIncludePaths(fromFilename, base = []) {
+    if (fromFilename == null)
+        return [];
+    return [
+        ...new Set([...base, 'node_modules', process.cwd(), (0, path_1.dirname)(fromFilename)]),
+    ];
+}
+exports.getIncludePaths = getIncludePaths;
+const depCheckCache = {};
+/**
+ * Checks if a package is installed.
+ *
+ * @export
+ * @param {string} dep
+ * @returns boolean
+ */
+async function hasDepInstalled(dep) {
+    if (depCheckCache[dep] != null) {
+        return depCheckCache[dep];
+    }
+    let result = false;
+    try {
+        await Promise.resolve(`${dep}`).then(s => __importStar(require(s)));
+        result = true;
+    }
+    catch (e) {
+        result = false;
+    }
+    return (depCheckCache[dep] = result);
+}
+exports.hasDepInstalled = hasDepInstalled;
+function isValidLocalPath(path) {
+    return path.startsWith('.');
+}
+exports.isValidLocalPath = isValidLocalPath;
+// finds a existing path up the tree
+function findUp({ what, from }) {
+    const { root, dir } = (0, path_1.parse)(from);
+    let cur = dir;
+    try {
+        while (cur !== root) {
+            const possiblePath = (0, path_1.join)(cur, what);
+            if ((0, fs_1.existsSync)(possiblePath)) {
+                return possiblePath;
+            }
+            cur = (0, path_1.dirname)(cur);
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return null;
+}
+exports.findUp = findUp;
+// set deep property in object
+function setProp(obj, keyList, value) {
+    let i = 0;
+    for (; i < keyList.length - 1; i++) {
+        const key = keyList[i];
+        if (typeof obj[key] !== 'object') {
+            obj[key] = {};
+        }
+        obj = obj[key];
+    }
+    obj[keyList[i]] = value;
+}
+exports.setProp = setProp;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/processors/babel.d.ts

@@ -0,0 +1,4 @@
+import type { PreprocessorGroup, Options } from '../types';
+declare const babel: (options?: Options.Babel) => PreprocessorGroup;
+export default babel;
+export { babel };

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/processors/babel.js

@@ -0,0 +1,50 @@
+"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.babel = void 0;
+const utils_1 = require("../modules/utils");
+const tagInfo_1 = require("../modules/tagInfo");
+const prepareContent_1 = require("../modules/prepareContent");
+const babel = (options) => ({
+    async script(svelteFile) {
+        const { transformer } = await Promise.resolve().then(() => __importStar(require('../transformers/babel')));
+        let { content, filename, dependencies, attributes } = await (0, tagInfo_1.getTagInfo)(svelteFile);
+        content = (0, prepareContent_1.prepareContent)({ options, content });
+        const transformed = await transformer({
+            content,
+            filename,
+            attributes,
+            options,
+        });
+        return {
+            ...transformed,
+            dependencies: (0, utils_1.concat)(dependencies, transformed.dependencies),
+        };
+    },
+});
+exports.babel = babel;
+// both for backwards compat with old svelte-preprocess versions
+// (was only default export once, now is named export because of transpilation causing node not to detect the named exports of 'svelte-preprocess' otherwise)
+exports.default = babel;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/processors/coffeescript.d.ts

@@ -0,0 +1,4 @@
+import type { PreprocessorGroup, Options } from '../types';
+declare const coffeescript: (options?: Options.Coffeescript) => PreprocessorGroup;
+export default coffeescript;
+export { coffeescript };

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/processors/coffeescript.js

@@ -0,0 +1,59 @@
+"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.coffeescript = void 0;
+const tagInfo_1 = require("../modules/tagInfo");
+const utils_1 = require("../modules/utils");
+const prepareContent_1 = require("../modules/prepareContent");
+const coffeescript = (options) => ({
+    async script(svelteFile) {
+        const { transformer } = await Promise.resolve().then(() => __importStar(require('../transformers/coffeescript')));
+        let { content, filename, attributes, lang, dependencies } = await (0, tagInfo_1.getTagInfo)(svelteFile);
+        if (lang !== 'coffeescript') {
+            return { code: content };
+        }
+        content = (0, prepareContent_1.prepareContent)({
+            options: {
+                ...options,
+                stripIndent: true,
+            },
+            content,
+        });
+        const transformed = await transformer({
+            content,
+            filename,
+            attributes,
+            options,
+        });
+        return {
+            ...transformed,
+            dependencies: (0, utils_1.concat)(dependencies, transformed.dependencies),
+        };
+    },
+});
+exports.coffeescript = coffeescript;
+// both for backwards compat with old svelte-preprocess versions
+// (was only default export once, now is named export because of transpilation causing node not to detect the named exports of 'svelte-preprocess' otherwise)
+exports.default = coffeescript;

data/lib/mount_svelte/node_modules/svelte-preprocess/dist/processors/globalStyle.d.ts

@@ -0,0 +1,4 @@
+import type { PreprocessorGroup } from '../types';
+declare const globalStyle: () => PreprocessorGroup;
+export default globalStyle;
+export { globalStyle };