svelte-on-rails 0.0.1

data/lib/mount_svelte/node_modules/@rollup/plugin-commonjs/dist/es/package.json

@@ -0,0 +1 @@
+{"type":"module"}

data/lib/mount_svelte/node_modules/@rollup/plugin-commonjs/node_modules/is-reference/CHANGELOG.md

@@ -0,0 +1,37 @@
+# is-reference changelog
+
+## 1.2.1
+
+* Relax version range for `@types/estree`
+
+## 1.2.0
+
+* Handle class fields ([#](https://github.com/Rich-Harris/is-reference/pull/8))
+
+## 1.1.4
+
+* Disregarded imported specifiers if they differ from local specifiers
+
+## 1.1.3
+
+* Handle expressions without a Program
+
+## 1.1.2
+
+* Ignore labels in break/continue statements ([#4](https://github.com/Rich-Harris/is-reference/pull/4))
+
+## 1.1.1
+
+* Prevent false positives with labeled statements
+
+## 1.1.0
+
+* Rewrite in TypeScript, add declarations
+
+## 1.0.1
+
+* Ensure `isReference` returns a boolean
+
+## 1.0.0
+
+* First release

data/lib/mount_svelte/node_modules/@rollup/plugin-commonjs/node_modules/is-reference/README.md

@@ -0,0 +1,61 @@
+# is-reference
+
+Utility for determining whether an AST node is a reference.
+
+`foo` is a reference in these cases:
+
+```js
+console.log( foo );
+var foo;
+function foo () {}
+function bar ( foo ) {}
+export { foo as x };
+```
+
+`foo` is *not* a reference in these cases:
+
+```js
+var obj = { foo: 1 };
+console.log( obj.foo );
+export { x as foo };
+```
+
+In all cases, `foo` is an `Identifier` node, but the two kinds must be treated differently for the purposes of scope analysis etc. (The examples are non-exhaustive.)
+
+
+## Installation
+
+```bash
+npm install is-reference
+```
+
+
+## Usage
+
+Example using [Acorn](https://github.com/ternjs/acorn) and [estree-walker](https://github.com/Rich-Harris/estree-walker):
+
+```js
+const { parse } = require( 'acorn' );
+const { walk } = require( 'estree-walker' );
+const isReference = require( 'is-reference' );
+
+const identifiers = [];
+const references = [];
+
+const ast = parse( `var a = b.c;` );
+
+walk( ast, {
+	enter ( node, parent ) {
+		if ( node.type === 'Identifier' ) identifiers.push( node );
+		if ( isReference( node, parent ) ) references.push( node );
+	}
+});
+
+identifiers.forEach( node => console.log( node.name ) ); // a, b, c
+references.forEach( node => console.log( node.name ) ); // a, b
+```
+
+
+## License
+
+MIT

data/lib/mount_svelte/node_modules/@rollup/plugin-commonjs/node_modules/is-reference/dist/is-reference.es.js

@@ -0,0 +1,31 @@
+function isReference(node, parent) {
+    if (node.type === 'MemberExpression') {
+        return !node.computed && isReference(node.object, node);
+    }
+    if (node.type === 'Identifier') {
+        if (!parent)
+            return true;
+        switch (parent.type) {
+            // disregard `bar` in `foo.bar`
+            case 'MemberExpression': return parent.computed || node === parent.object;
+            // disregard the `foo` in `class {foo(){}}` but keep it in `class {[foo](){}}`
+            case 'MethodDefinition': return parent.computed;
+            // disregard the `foo` in `class {foo=bar}` but keep it in `class {[foo]=bar}` and `class {bar=foo}`
+            case 'FieldDefinition': return parent.computed || node === parent.value;
+            // disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
+            case 'Property': return parent.computed || node === parent.value;
+            // disregard the `bar` in `export { foo as bar }` or
+            // the foo in `import { foo as bar }`
+            case 'ExportSpecifier':
+            case 'ImportSpecifier': return node === parent.local;
+            // disregard the `foo` in `foo: while (...) { ... break foo; ... continue foo;}`
+            case 'LabeledStatement':
+            case 'BreakStatement':
+            case 'ContinueStatement': return false;
+            default: return true;
+        }
+    }
+    return false;
+}
+
+export default isReference;

data/lib/mount_svelte/node_modules/@rollup/plugin-commonjs/node_modules/is-reference/dist/is-reference.js

@@ -0,0 +1,39 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+	typeof define === 'function' && define.amd ? define(factory) :
+	(global = global || self, global.isReference = factory());
+}(this, (function () { 'use strict';
+
+	function isReference(node, parent) {
+	    if (node.type === 'MemberExpression') {
+	        return !node.computed && isReference(node.object, node);
+	    }
+	    if (node.type === 'Identifier') {
+	        if (!parent)
+	            return true;
+	        switch (parent.type) {
+	            // disregard `bar` in `foo.bar`
+	            case 'MemberExpression': return parent.computed || node === parent.object;
+	            // disregard the `foo` in `class {foo(){}}` but keep it in `class {[foo](){}}`
+	            case 'MethodDefinition': return parent.computed;
+	            // disregard the `foo` in `class {foo=bar}` but keep it in `class {[foo]=bar}` and `class {bar=foo}`
+	            case 'FieldDefinition': return parent.computed || node === parent.value;
+	            // disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
+	            case 'Property': return parent.computed || node === parent.value;
+	            // disregard the `bar` in `export { foo as bar }` or
+	            // the foo in `import { foo as bar }`
+	            case 'ExportSpecifier':
+	            case 'ImportSpecifier': return node === parent.local;
+	            // disregard the `foo` in `foo: while (...) { ... break foo; ... continue foo;}`
+	            case 'LabeledStatement':
+	            case 'BreakStatement':
+	            case 'ContinueStatement': return false;
+	            default: return true;
+	        }
+	    }
+	    return false;
+	}
+
+	return isReference;
+
+})));

data/lib/mount_svelte/node_modules/@rollup/plugin-commonjs/node_modules/is-reference/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+import { Node } from 'estree';
+export default function isReference(node: Node, parent: Node): boolean;

data/lib/mount_svelte/node_modules/@rollup/plugin-commonjs/node_modules/is-reference/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "is-reference",
+  "version": "1.2.1",
+  "description": "Determine whether an AST node is a reference",
+  "main": "dist/is-reference.js",
+  "module": "dist/is-reference.es.js",
+  "types": "dist/types/index.d.ts",
+  "files": [
+    "dist/*.js",
+    "dist/types/**/*.d.ts"
+  ],
+  "scripts": {
+    "test": "mocha",
+    "build": "rollup -c && tsc --emitDeclarationOnly",
+    "pretest": "npm run build",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rich-Harris/is-reference.git"
+  },
+  "keywords": [
+    "ast",
+    "javascript",
+    "estree",
+    "acorn"
+  ],
+  "author": "Rich Harris",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Rich-Harris/is-reference/issues"
+  },
+  "homepage": "https://github.com/Rich-Harris/is-reference#readme",
+  "dependencies": {
+    "@types/estree": "*"
+  },
+  "devDependencies": {
+    "acorn": "^7.2.0",
+    "acorn-class-fields": "^0.3.2",
+    "acorn-static-class-features": "^0.2.1",
+    "estree-walker": "^2.0.1",
+    "mocha": "^7.1.2",
+    "rollup": "^2.10.3",
+    "rollup-plugin-typescript": "^1.0.1",
+    "tslib": "^2.0.0",
+    "typescript": "^3.9.2"
+  }
+}

data/lib/mount_svelte/node_modules/@rollup/plugin-commonjs/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@rollup/plugin-commonjs",
+  "version": "28.0.3",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Convert CommonJS modules to ES2015",
+  "license": "MIT",
+  "repository": {
+    "url": "rollup/plugins",
+    "directory": "packages/commonjs"
+  },
+  "author": "Rich Harris <richard.a.harris@gmail.com>",
+  "homepage": "https://github.com/rollup/plugins/tree/master/packages/commonjs/#readme",
+  "bugs": "https://github.com/rollup/plugins/issues",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/es/index.js",
+  "exports": {
+    "types": "./types/index.d.ts",
+    "import": "./dist/es/index.js",
+    "default": "./dist/cjs/index.js"
+  },
+  "engines": {
+    "node": ">=16.0.0 || 14 >= 14.17"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "types",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "rollup",
+    "plugin",
+    "npm",
+    "modules",
+    "commonjs",
+    "require"
+  ],
+  "peerDependencies": {
+    "rollup": "^2.68.0||^3.0.0||^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "rollup": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@rollup/pluginutils": "^5.0.1",
+    "commondir": "^1.0.1",
+    "estree-walker": "^2.0.2",
+    "fdir": "^6.2.0",
+    "is-reference": "1.2.1",
+    "magic-string": "^0.30.3",
+    "picomatch": "^4.0.2"
+  },
+  "devDependencies": {
+    "@rollup/plugin-json": "^5.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.0",
+    "locate-character": "^2.0.5",
+    "require-relative": "^0.8.7",
+    "rollup": "^4.0.0-24",
+    "source-map": "^0.7.4",
+    "source-map-support": "^0.5.21",
+    "typescript": "^4.8.3"
+  },
+  "types": "./types/index.d.ts",
+  "ava": {
+    "workerThreads": false,
+    "files": [
+      "!**/fixtures/**",
+      "!**/helpers/**",
+      "!**/recipes/**",
+      "!**/types.ts"
+    ]
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "ci:coverage": "nyc pnpm test && nyc report --reporter=text-lcov > coverage.lcov",
+    "ci:lint": "pnpm build && pnpm lint",
+    "ci:lint:commits": "commitlint --from=${CIRCLE_BRANCH} --to=${CIRCLE_SHA1}",
+    "ci:test": "pnpm test -- --verbose && pnpm test:ts",
+    "prebuild": "del-cli dist",
+    "prerelease": "pnpm build",
+    "pretest": "pnpm build",
+    "release": "pnpm --workspace-root package:release $(pwd)",
+    "test": "ava",
+    "test:ts": "tsc types/index.d.ts test/types.ts --noEmit"
+  }
+}

data/lib/mount_svelte/node_modules/@rollup/plugin-commonjs/types/index.d.ts

@@ -0,0 +1,233 @@
+import type { FilterPattern } from '@rollup/pluginutils';
+import type { Plugin } from 'rollup';
+
+type RequireReturnsDefaultOption = boolean | 'auto' | 'preferred' | 'namespace';
+type DefaultIsModuleExportsOption = boolean | 'auto';
+
+interface RollupCommonJSOptions {
+  /**
+   * A picomatch pattern, or array of patterns, which specifies the files in
+   * the build the plugin should operate on. By default, all files with
+   * extension `".cjs"` or those in `extensions` are included, but you can
+   * narrow this list by only including specific files. These files will be
+   * analyzed and transpiled if either the analysis does not find ES module
+   * specific statements or `transformMixedEsModules` is `true`.
+   * @default undefined
+   */
+  include?: FilterPattern;
+  /**
+   * A picomatch pattern, or array of patterns, which specifies the files in
+   * the build the plugin should _ignore_. By default, all files with
+   * extensions other than those in `extensions` or `".cjs"` are ignored, but you
+   * can exclude additional files. See also the `include` option.
+   * @default undefined
+   */
+  exclude?: FilterPattern;
+  /**
+   * For extensionless imports, search for extensions other than .js in the
+   * order specified. Note that you need to make sure that non-JavaScript files
+   * are transpiled by another plugin first.
+   * @default [ '.js' ]
+   */
+  extensions?: ReadonlyArray<string>;
+  /**
+   * If true then uses of `global` won't be dealt with by this plugin
+   * @default false
+   */
+  ignoreGlobal?: boolean;
+  /**
+   * If false, skips source map generation for CommonJS modules. This will
+   * improve performance.
+   * @default true
+   */
+  sourceMap?: boolean;
+  /**
+   * Some `require` calls cannot be resolved statically to be translated to
+   * imports.
+   * When this option is set to `false`, the generated code will either
+   * directly throw an error when such a call is encountered or, when
+   * `dynamicRequireTargets` is used, when such a call cannot be resolved with a
+   * configured dynamic require target.
+   * Setting this option to `true` will instead leave the `require` call in the
+   * code or use it as a fallback for `dynamicRequireTargets`.
+   * @default false
+   */
+  ignoreDynamicRequires?: boolean;
+  /**
+   * Instructs the plugin whether to enable mixed module transformations. This
+   * is useful in scenarios with modules that contain a mix of ES `import`
+   * statements and CommonJS `require` expressions. Set to `true` if `require`
+   * calls should be transformed to imports in mixed modules, or `false` if the
+   * `require` expressions should survive the transformation. The latter can be
+   * important if the code contains environment detection, or you are coding
+   * for an environment with special treatment for `require` calls such as
+   * ElectronJS. See also the `ignore` option.
+   * @default false
+   */
+  transformMixedEsModules?: boolean;
+  /**
+   * By default, this plugin will try to hoist `require` statements as imports
+   * to the top of each file. While this works well for many code bases and
+   * allows for very efficient ESM output, it does not perfectly capture
+   * CommonJS semantics as the order of side effects like log statements may
+   * change. But it is especially problematic when there are circular `require`
+   * calls between CommonJS modules as those often rely on the lazy execution of
+   * nested `require` calls.
+   *
+   * Setting this option to `true` will wrap all CommonJS files in functions
+   * which are executed when they are required for the first time, preserving
+   * NodeJS semantics. Note that this can have an impact on the size and
+   * performance of the generated code.
+   *
+   * The default value of `"auto"` will only wrap CommonJS files when they are
+   * part of a CommonJS dependency cycle, e.g. an index file that is required by
+   * many of its dependencies. All other CommonJS files are hoisted. This is the
+   * recommended setting for most code bases.
+   *
+   * `false` will entirely prevent wrapping and hoist all files. This may still
+   * work depending on the nature of cyclic dependencies but will often cause
+   * problems.
+   *
+   * You can also provide a picomatch pattern, or array of patterns, to only
+   * specify a subset of files which should be wrapped in functions for proper
+   * `require` semantics.
+   *
+   * `"debug"` works like `"auto"` but after bundling, it will display a warning
+   * containing a list of ids that have been wrapped which can be used as
+   * picomatch pattern for fine-tuning.
+   * @default "auto"
+   */
+  strictRequires?: boolean | FilterPattern;
+  /**
+   * Sometimes you have to leave require statements unconverted. Pass an array
+   * containing the IDs or a `id => boolean` function.
+   * @default []
+   */
+  ignore?: ReadonlyArray<string> | ((id: string) => boolean);
+  /**
+   * In most cases, where `require` calls are inside a `try-catch` clause,
+   * they should be left unconverted as it requires an optional dependency
+   * that may or may not be installed beside the rolled up package.
+   * Due to the conversion of `require` to a static `import` - the call is
+   * hoisted to the top of the file, outside the `try-catch` clause.
+   *
+   * - `true`: Default. All `require` calls inside a `try` will be left unconverted.
+   * - `false`: All `require` calls inside a `try` will be converted as if the
+   *   `try-catch` clause is not there.
+   * - `remove`: Remove all `require` calls from inside any `try` block.
+   * - `string[]`: Pass an array containing the IDs to left unconverted.
+   * - `((id: string) => boolean|'remove')`: Pass a function that controls
+   *   individual IDs.
+   *
+   * @default true
+   */
+  ignoreTryCatch?:
+    | boolean
+    | 'remove'
+    | ReadonlyArray<string>
+    | ((id: string) => boolean | 'remove');
+  /**
+   * Controls how to render imports from external dependencies. By default,
+   * this plugin assumes that all external dependencies are CommonJS. This
+   * means they are rendered as default imports to be compatible with e.g.
+   * NodeJS where ES modules can only import a default export from a CommonJS
+   * dependency.
+   *
+   * If you set `esmExternals` to `true`, this plugin assumes that all
+   * external dependencies are ES modules and respect the
+   * `requireReturnsDefault` option. If that option is not set, they will be
+   * rendered as namespace imports.
+   *
+   * You can also supply an array of ids to be treated as ES modules, or a
+   * function that will be passed each external id to determine whether it is
+   * an ES module.
+   * @default false
+   */
+  esmExternals?: boolean | ReadonlyArray<string> | ((id: string) => boolean);
+  /**
+   * Controls what is returned when requiring an ES module from a CommonJS file.
+   * When using the `esmExternals` option, this will also apply to external
+   * modules. By default, this plugin will render those imports as namespace
+   * imports i.e.
+   *
+   * ```js
+   * // input
+   * const foo = require('foo');
+   *
+   * // output
+   * import * as foo from 'foo';
+   * ```
+   *
+   * However, there are some situations where this may not be desired.
+   * For these situations, you can change Rollup's behaviour either globally or
+   * per module. To change it globally, set the `requireReturnsDefault` option
+   * to one of the following values:
+   *
+   * - `false`: This is the default, requiring an ES module returns its
+   *   namespace. This is the only option that will also add a marker
+   *   `__esModule: true` to the namespace to support interop patterns in
+   *   CommonJS modules that are transpiled ES modules.
+   * - `"namespace"`: Like `false`, requiring an ES module returns its
+   *   namespace, but the plugin does not add the `__esModule` marker and thus
+   *   creates more efficient code. For external dependencies when using
+   *   `esmExternals: true`, no additional interop code is generated.
+   * - `"auto"`: This is complementary to how `output.exports: "auto"` works in
+   *   Rollup: If a module has a default export and no named exports, requiring
+   *   that module returns the default export. In all other cases, the namespace
+   *   is returned. For external dependencies when using `esmExternals: true`, a
+   *   corresponding interop helper is added.
+   * - `"preferred"`: If a module has a default export, requiring that module
+   *   always returns the default export, no matter whether additional named
+   *   exports exist. This is similar to how previous versions of this plugin
+   *   worked. Again for external dependencies when using `esmExternals: true`,
+   *   an interop helper is added.
+   * - `true`: This will always try to return the default export on require
+   *   without checking if it actually exists. This can throw at build time if
+   *   there is no default export. This is how external dependencies are handled
+   *   when `esmExternals` is not used. The advantage over the other options is
+   *   that, like `false`, this does not add an interop helper for external
+   *   dependencies, keeping the code lean.
+   *
+   * To change this for individual modules, you can supply a function for
+   * `requireReturnsDefault` instead. This function will then be called once for
+   * each required ES module or external dependency with the corresponding id
+   * and allows you to return different values for different modules.
+   * @default false
+   */
+  requireReturnsDefault?:
+    | RequireReturnsDefaultOption
+    | ((id: string) => RequireReturnsDefaultOption);
+
+  /**
+   * @default "auto"
+   */
+  defaultIsModuleExports?:
+    | DefaultIsModuleExportsOption
+    | ((id: string) => DefaultIsModuleExportsOption);
+  /**
+   * Some modules contain dynamic `require` calls, or require modules that
+   * contain circular dependencies, which are not handled well by static
+   * imports. Including those modules as `dynamicRequireTargets` will simulate a
+   * CommonJS (NodeJS-like) environment for them with support for dynamic
+   * dependencies. It also enables `strictRequires` for those modules.
+   *
+   * Note: In extreme cases, this feature may result in some paths being
+   * rendered as absolute in the final bundle. The plugin tries to avoid
+   * exposing paths from the local machine, but if you are `dynamicRequirePaths`
+   * with paths that are far away from your project's folder, that may require
+   * replacing strings like `"/Users/John/Desktop/foo-project/"` -> `"/"`.
+   */
+  dynamicRequireTargets?: string | ReadonlyArray<string>;
+  /**
+   * To avoid long paths when using the `dynamicRequireTargets` option, you can use this option to specify a directory
+   * that is a common parent for all files that use dynamic require statements. Using a directory higher up such as `/`
+   * may lead to unnecessarily long paths in the generated code and may expose directory names on your machine like your
+   * home directory name. By default, it uses the current working directory.
+   */
+  dynamicRequireRoot?: string;
+}
+
+/**
+ * Convert CommonJS modules to ES6, so they can be included in a Rollup bundle
+ */
+export default function commonjs(options?: RollupCommonJSOptions): Plugin;

data/lib/mount_svelte/node_modules/@rollup/plugin-node-resolve/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 RollupJS Plugin Contributors (https://github.com/rollup/plugins/graphs/contributors)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.