chamomind/elearning
7
0
Fork 0
Code Issues 4 Pull requests Projects Releases Packages 3 Wiki Activity Actions

Website Structure

Browse source
This commit is contained in:
supalerk-ar66 2026-01-13 10:46:40 +07:00
parent 62812f2090
commit 71f0676a62
22365 changed files with 4265753 additions and 791 deletions
Download patch file Download diff file Expand all files Collapse all files

21
Frontend-Learner/node_modules/externality/LICENSE generated vendored Normal file
View file

@ -0,0 +1,21 @@
MIT License
Copyright (c) Pooya Parsa <pooya@pi0.io> - Daniel Roe <daniel@roe.dev>
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.

82
Frontend-Learner/node_modules/externality/README.md generated vendored Normal file
View file

@ -0,0 +1,82 @@
[![npm version][npm-version-src]][npm-version-href]
[![npm downloads][npm-downloads-src]][npm-downloads-href]
[![Github Actions][github-actions-src]][github-actions-href]
[![Codecov][codecov-src]][codecov-href]
[![bundle][bundle-src]][bundle-href]
# Externality
Externality is a set of utilities for handling identifying whether a given package or path should be considered an external package that can be imported at runtime, or whether is should be bundled in a build step.
It also contains a webpack and rollup plugin for encapsulating this functionality.
## Install
Install using npm or yarn:
```bash
npm i externality
# or
yarn add externality
```
## Rollup plugin
```js
import { rollupExternals } from 'externality'
```
## Webpack plugin
```js
import { webpackExternals } from 'externality'
```
## Utils
### `resolveId`
This utility is powered by [`enhanced-resolve`](https://github.com/webpack/enhanced-resolve) and will resolve a given module/path with support for extensions, CJS/ESM and more.
```js
import { resolveId } from 'externality'
await resolveId('my-lib', { type: 'commonjs' })
// {
// id: 'my-lib',
// path: '/path/to/node_modules/my-lib/index.js',
// type: 'commonjs'
// }
```
### `isExternal`
```js
import { isExternal } from 'externality'
await isExternal('my-lib', '.')
// {
// id: 'my-lib',
// external: true
// }
```
## License
[MIT](./LICENSE)
<!-- Badges -->
[npm-version-src]: https://img.shields.io/npm/v/externality?style=flat-square
[npm-version-href]: https://npmjs.com/package/externality
[npm-downloads-src]: https://img.shields.io/npm/dm/externality?style=flat-square
[npm-downloads-href]: https://npmjs.com/package/externality
[github-actions-src]: https://img.shields.io/github/workflow/status/unjs/externality/ci/main?style=flat-square
[github-actions-href]: https://github.com/unjs/externality/actions?query=workflow%3Aci
[codecov-src]: https://img.shields.io/codecov/c/gh/unjs/externality/main?style=flat-square
[codecov-href]: https://codecov.io/gh/unjs/externality
[bundle-src]: https://img.shields.io/bundlephobia/minzip/externality?style=flat-square
[bundle-href]: https://bundlephobia.com/result?p=externality

169
Frontend-Learner/node_modules/externality/dist/index.cjs generated vendored Normal file
View file

@ -0,0 +1,169 @@
'use strict';
const node_url = require('node:url');
const node_util = require('node:util');
const ufo = require('ufo');
const enhancedResolve = require('enhanced-resolve');
const mlly = require('mlly');
const pathe = require('pathe');
function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
const enhancedResolve__default = /*#__PURE__*/_interopDefaultCompat(enhancedResolve);
const ProtocolRegex = /^(?<proto>.{2,}):.+$/;
function getProtocol(id) {
const proto = id.match(ProtocolRegex);
return proto ? proto.groups.proto : null;
}
function matches(input, matchers, context) {
return matchers.some((matcher) => {
if (matcher instanceof RegExp) {
return matcher.test(input);
}
if (typeof matcher === "function") {
return matcher(input, context);
}
return false;
});
}
function toMatcher(pattern) {
if (typeof pattern !== "string") {
return pattern;
}
pattern = pattern.replace(/\//g, "[\\\\/+]");
return new RegExp(`([\\/]|^)${pattern}(@[^\\/]*)?([\\/](?!node_modules)|$)`);
}
function getType(id, fallback = "commonjs") {
if (id.endsWith(".cjs")) {
return "commonjs";
}
if (id.endsWith(".mjs")) {
return "module";
}
return fallback;
}
const DefaultResolveOptions = {
extensions: [".ts", ".mjs", ".cjs", ".js", ".json"],
type: "commonjs"
};
async function resolveId(id, base = ".", options = {}) {
options = { ...DefaultResolveOptions, ...options };
if (!options.conditionNames) {
options.conditionNames = [options.type === "commonjs" ? "require" : "import"];
}
if (mlly.isNodeBuiltin(id)) {
return {
id: id.replace(/^node:/, ""),
path: id,
type: options.type,
external: true
};
}
if (id.startsWith("file:/")) {
id = node_url.fileURLToPath(id);
}
if (ufo.hasProtocol(id)) {
const url = new URL(id);
return {
id: url.href,
path: url.pathname,
type: getType(id, options.type),
external: true
};
}
if (base.includes("\0")) {
base = options.roots?.[0] || ".";
}
const _resolve = node_util.promisify(enhancedResolve__default.create(options));
const resolvedModule = await _resolve(base, id);
return {
id,
path: resolvedModule || id,
type: getType(resolvedModule || id, "unknown")
};
}
const ExternalsDefaults = {
inline: [
// Rollup
// eslint-disable-next-line no-control-regex
/\u0000/,
// Webpack
/^!/,
/^-!/,
// Common
/^#/,
/\?/
],
external: [],
externalProtocols: ["node", "file", "data"],
externalExtensions: [".js", ".mjs", ".cjs", ".node"],
resolve: {},
detectInvalidNodeImports: true
};
async function isExternal(id, importer, options = {}) {
options = { ...ExternalsDefaults, ...options };
const inlineMatchers = options.inline.map((p) => toMatcher(p));
const externalMatchers = options.external.map((p) => toMatcher(p));
const context = { opts: options, id, resolved: null };
if (!id || matches(id, inlineMatchers, context)) {
return null;
}
const proto = getProtocol(id);
if (proto && !options.externalProtocols.includes(proto)) {
return null;
}
if (proto === "data") {
return { id, external: true };
}
const r = context.resolved = await resolveId(id, importer, options.resolve).catch(() => {
return { id, path: id, external: null };
});
const idExtension = pathe.extname(r.path);
if (idExtension && !options.externalExtensions.includes(idExtension)) {
return null;
}
if (matches(r.id, inlineMatchers, context) || matches(r.path, inlineMatchers, context)) {
return null;
}
if (r.external || matches(id, externalMatchers, context) || matches(r.id, externalMatchers, context) || matches(r.path, externalMatchers, context)) {
if (options.detectInvalidNodeImports && !await mlly.isValidNodeImport(r.path)) {
return null;
}
return { id: r.id, external: true };
}
return null;
}
function rollupExternals(options) {
return {
name: "node-externals",
resolveId(id, importer) {
return isExternal(id, importer, options);
}
};
}
function webpackExternals(options) {
const _isExternal = async ({ request }, callback) => {
try {
const res = await isExternal(request, ".", options);
callback(void 0, res && res.id);
} catch (error) {
callback(error, null);
}
};
return _isExternal;
}
exports.ExternalsDefaults = ExternalsDefaults;
exports.getProtocol = getProtocol;
exports.getType = getType;
exports.isExternal = isExternal;
exports.matches = matches;
exports.resolveId = resolveId;
exports.rollupExternals = rollupExternals;
exports.toMatcher = toMatcher;
exports.webpackExternals = webpackExternals;

70
Frontend-Learner/node_modules/externality/dist/index.d.ts generated vendored Normal file
View file

@ -0,0 +1,70 @@
import { ResolveOptions as ResolveOptions$1 } from 'enhanced-resolve';
import { Plugin } from 'rollup';
type ModuleType = "commonjs" | "module" | "unknown";
interface ResolveOptions extends Partial<ResolveOptions$1> {
/**
* Whether to resolve esm or cjs by default
* @default 'commonjs'
*/
type?: ModuleType;
}
interface ResolvedId {
id: string;
path: string;
type?: ModuleType;
external?: boolean;
}
declare function resolveId(id: string, base?: string, options?: ResolveOptions): Promise<ResolvedId>;
type Matcher<T = any> = RegExp | ((input: string, context?: T) => boolean);
declare function getProtocol(id: string): string | null;
declare function matches<T = any>(input: string, matchers: Matcher<T>[], context?: T): boolean;
declare function toMatcher(pattern: string): RegExp;
declare function toMatcher<T>(pattern: Matcher<T>): Matcher<T>;
declare function getType(id: string, fallback?: ModuleType): ModuleType;
interface ExternalsOptions {
/**
* Patterns that always will be excluded from externals
*/
inline?: Array<string | Matcher>;
/**
* Patterns that match if an id/module is external
*/
external?: Array<string | Matcher>;
/**
* Protocols that are allowed to be externalized.
* Any other matched protocol will be inlined.
*
* Default: ['node', 'file', 'data']
*/
externalProtocols?: Array<string>;
/**
* Extensions that are allowed to be externalized.
* Any other matched extension will be inlined.
*
* Default: ['.js', '.mjs', '.cjs', '.node']
*/
externalExtensions?: Array<string>;
/**
* Resolve options (passed directly to [`enhanced-resolve`](https://github.com/webpack/enhanced-resolve))
*/
resolve?: Partial<ResolveOptions>;
/**
* Try to automatically detect and inline invalid node imports
* matching file name (at first) and then loading code.
*/
detectInvalidNodeImports?: boolean;
}
declare const ExternalsDefaults: ExternalsOptions;
declare function isExternal(id: string, importer: string, options?: ExternalsOptions): Promise<null | {
id: string;
external: true;
}>;
declare function rollupExternals(options: ExternalsOptions): Plugin;
declare function webpackExternals(options: ExternalsOptions): any;
export { ExternalsDefaults, ExternalsOptions, Matcher, ModuleType, ResolveOptions, ResolvedId, getProtocol, getType, isExternal, matches, resolveId, rollupExternals, toMatcher, webpackExternals };

155
Frontend-Learner/node_modules/externality/dist/index.mjs generated vendored Normal file
View file

@ -0,0 +1,155 @@
import { fileURLToPath } from 'node:url';
import { promisify } from 'node:util';
import { hasProtocol } from 'ufo';
import enhancedResolve from 'enhanced-resolve';
import { isNodeBuiltin, isValidNodeImport } from 'mlly';
import { extname } from 'pathe';
const ProtocolRegex = /^(?<proto>.{2,}):.+$/;
function getProtocol(id) {
const proto = id.match(ProtocolRegex);
return proto ? proto.groups.proto : null;
}
function matches(input, matchers, context) {
return matchers.some((matcher) => {
if (matcher instanceof RegExp) {
return matcher.test(input);
}
if (typeof matcher === "function") {
return matcher(input, context);
}
return false;
});
}
function toMatcher(pattern) {
if (typeof pattern !== "string") {
return pattern;
}
pattern = pattern.replace(/\//g, "[\\\\/+]");
return new RegExp(`([\\/]|^)${pattern}(@[^\\/]*)?([\\/](?!node_modules)|$)`);
}
function getType(id, fallback = "commonjs") {
if (id.endsWith(".cjs")) {
return "commonjs";
}
if (id.endsWith(".mjs")) {
return "module";
}
return fallback;
}
const DefaultResolveOptions = {
extensions: [".ts", ".mjs", ".cjs", ".js", ".json"],
type: "commonjs"
};
async function resolveId(id, base = ".", options = {}) {
options = { ...DefaultResolveOptions, ...options };
if (!options.conditionNames) {
options.conditionNames = [options.type === "commonjs" ? "require" : "import"];
}
if (isNodeBuiltin(id)) {
return {
id: id.replace(/^node:/, ""),
path: id,
type: options.type,
external: true
};
}
if (id.startsWith("file:/")) {
id = fileURLToPath(id);
}
if (hasProtocol(id)) {
const url = new URL(id);
return {
id: url.href,
path: url.pathname,
type: getType(id, options.type),
external: true
};
}
if (base.includes("\0")) {
base = options.roots?.[0] || ".";
}
const _resolve = promisify(enhancedResolve.create(options));
const resolvedModule = await _resolve(base, id);
return {
id,
path: resolvedModule || id,
type: getType(resolvedModule || id, "unknown")
};
}
const ExternalsDefaults = {
inline: [
// Rollup
// eslint-disable-next-line no-control-regex
/\u0000/,
// Webpack
/^!/,
/^-!/,
// Common
/^#/,
/\?/
],
external: [],
externalProtocols: ["node", "file", "data"],
externalExtensions: [".js", ".mjs", ".cjs", ".node"],
resolve: {},
detectInvalidNodeImports: true
};
async function isExternal(id, importer, options = {}) {
options = { ...ExternalsDefaults, ...options };
const inlineMatchers = options.inline.map((p) => toMatcher(p));
const externalMatchers = options.external.map((p) => toMatcher(p));
const context = { opts: options, id, resolved: null };
if (!id || matches(id, inlineMatchers, context)) {
return null;
}
const proto = getProtocol(id);
if (proto && !options.externalProtocols.includes(proto)) {
return null;
}
if (proto === "data") {
return { id, external: true };
}
const r = context.resolved = await resolveId(id, importer, options.resolve).catch(() => {
return { id, path: id, external: null };
});
const idExtension = extname(r.path);
if (idExtension && !options.externalExtensions.includes(idExtension)) {
return null;
}
if (matches(r.id, inlineMatchers, context) || matches(r.path, inlineMatchers, context)) {
return null;
}
if (r.external || matches(id, externalMatchers, context) || matches(r.id, externalMatchers, context) || matches(r.path, externalMatchers, context)) {
if (options.detectInvalidNodeImports && !await isValidNodeImport(r.path)) {
return null;
}
return { id: r.id, external: true };
}
return null;
}
function rollupExternals(options) {
return {
name: "node-externals",
resolveId(id, importer) {
return isExternal(id, importer, options);
}
};
}
function webpackExternals(options) {
const _isExternal = async ({ request }, callback) => {
try {
const res = await isExternal(request, ".", options);
callback(void 0, res && res.id);
} catch (error) {
callback(error, null);
}
};
return _isExternal;
}
export { ExternalsDefaults, getProtocol, getType, isExternal, matches, resolveId, rollupExternals, toMatcher, webpackExternals };

44
Frontend-Learner/node_modules/externality/node_modules/pathe/LICENSE generated vendored Normal file
View file

@ -0,0 +1,44 @@
MIT License
Copyright (c) Pooya Parsa <pooya@pi0.io> - Daniel Roe <daniel@roe.dev>
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.
--------------------------------------------------------------------------------
Copyright Joyent, Inc. and other Node 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.

69
Frontend-Learner/node_modules/externality/node_modules/pathe/README.md generated vendored Normal file
View file

@ -0,0 +1,69 @@
# 🛣️ pathe
> Universal filesystem path utils
[![version][npm-v-src]][npm-v-href]
[![downloads][npm-d-src]][npm-d-href]
[![size][size-src]][size-href]
> **❓ Why**
>
> For [historical reasons](https://docs.microsoft.com/en-us/archive/blogs/larryosterman/why-is-the-dos-path-character), windows followed MS-DOS and using backslash for separating paths rather than slash used for macOS, Linux, and other Posix operating systems. Nowadays, [Windows](https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file?redirectedfrom=MSDN) supports both Slash and Backslash for paths. [Node.js's built in `path` module](https://nodejs.org/api/path.html) in the default operation of the path module varies based on the operating system on which a Node.js application is running. Specifically, when running on a Windows operating system, the path module will assume that Windows-style paths are being used. **This makes inconsistent code behavior between Windows and POSIX.**
> Compared to popular [upath](https://github.com/anodynos/upath), pathe is providing **identical exports** of Node.js with normalization on **all operations** and written in modern **ESM/Typescript** and has **no dependency on Node.js**!
This package is a drop-in replacement of the Node.js's [path module](https://nodejs.org/api/path.html) module and ensures paths are normalized with slash `/` and work in environments including Node.js.
## 💿 Usage
Install using npm or yarn:
```bash
# npm
npm i pathe
# yarn
yarn add pathe
# pnpm
pnpm i pathe
```
Import:
```js
// ESM / Typescript
import { resolve } from 'pathe'
// CommonJS
const { resolve } = require('pathe')
```
Read more about path utils from [Node.js documentation](https://nodejs.org/api/path.html) and rest assured behavior is ALWAYS like POSIX regardless of your input paths format and running platform!
### Extra utilties
Pathe exports some extra utilities that do not exist in standard Node.js [path module](https://nodejs.org/api/path.html).
In order to use them, you can import from `pathe/utils` subpath:
```js
import { filename, normalizeAliases, resolveAlias } from 'pathe/utils'
```
## License
MIT. Made with 💖
Some code used from Node.js project. See [LICENSE](./LICENSE).
<!-- Refs -->
[npm-v-src]: https://img.shields.io/npm/v/pathe?style=flat-square
[npm-v-href]: https://npmjs.com/package/pathe
[npm-d-src]: https://img.shields.io/npm/dm/pathe?style=flat-square
[npm-d-href]: https://npmjs.com/package/pathe
[github-actions-src]: https://img.shields.io/github/workflow/status/unjs/pathe/ci/main?style=flat-square
[github-actions-href]: https://github.com/unjs/pathe/actions?query=workflow%3Aci
[size-src]: https://packagephobia.now.sh/badge?p=pathe
[size-href]: https://packagephobia.now.sh/result?p=pathe

23
Frontend-Learner/node_modules/externality/node_modules/pathe/dist/index.cjs generated vendored Normal file
View file

@ -0,0 +1,23 @@
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
const index = require('./shared/pathe.1f0a373c.cjs');
exports.basename = index.basename;
exports.default = index.path;
exports.delimiter = index.delimiter;
exports.dirname = index.dirname;
exports.extname = index.extname;
exports.format = index.format;
exports.isAbsolute = index.isAbsolute;
exports.join = index.join;
exports.normalize = index.normalize;
exports.normalizeString = index.normalizeString;
exports.parse = index.parse;
exports.relative = index.relative;
exports.resolve = index.resolve;
exports.sep = index.sep;
exports.toNamespacedPath = index.toNamespacedPath;

36
Frontend-Learner/node_modules/externality/node_modules/pathe/dist/index.d.cts generated vendored Normal file
View file

@ -0,0 +1,36 @@
import path$1 from 'node:path';
declare const sep = "/";
declare const delimiter = ":";
declare const normalize: typeof path$1.normalize;
declare const join: typeof path$1.join;
declare const resolve: typeof path$1.resolve;
declare function normalizeString(path: string, allowAboveRoot: boolean): string;
declare const isAbsolute: typeof path$1.isAbsolute;
declare const toNamespacedPath: typeof path$1.toNamespacedPath;
declare const extname: typeof path$1.extname;
declare const relative: typeof path$1.relative;
declare const dirname: typeof path$1.dirname;
declare const format: typeof path$1.format;
declare const basename: typeof path$1.basename;
declare const parse: typeof path$1.parse;
declare const path_basename: typeof basename;
declare const path_delimiter: typeof delimiter;
declare const path_dirname: typeof dirname;
declare const path_extname: typeof extname;
declare const path_format: typeof format;
declare const path_isAbsolute: typeof isAbsolute;
declare const path_join: typeof join;
declare const path_normalize: typeof normalize;
declare const path_normalizeString: typeof normalizeString;
declare const path_parse: typeof parse;
declare const path_relative: typeof relative;
declare const path_resolve: typeof resolve;
declare const path_sep: typeof sep;
declare const path_toNamespacedPath: typeof toNamespacedPath;
declare namespace path {
export { path_basename as basename, path_delimiter as delimiter, path_dirname as dirname, path_extname as extname, path_format as format, path_isAbsolute as isAbsolute, path_join as join, path_normalize as normalize, path_normalizeString as normalizeString, path_parse as parse, path_relative as relative, path_resolve as resolve, path_sep as sep, path_toNamespacedPath as toNamespacedPath };
}
export { basename, path as default, delimiter, dirname, extname, format, isAbsolute, join, normalize, normalizeString, parse, relative, resolve, sep, toNamespacedPath };

36
Frontend-Learner/node_modules/externality/node_modules/pathe/dist/index.d.mts generated vendored Normal file
View file

@ -0,0 +1,36 @@
import path$1 from 'node:path';
declare const sep = "/";
declare const delimiter = ":";
declare const normalize: typeof path$1.normalize;
declare const join: typeof path$1.join;
declare const resolve: typeof path$1.resolve;
declare function normalizeString(path: string, allowAboveRoot: boolean): string;
declare const isAbsolute: typeof path$1.isAbsolute;
declare const toNamespacedPath: typeof path$1.toNamespacedPath;
declare const extname: typeof path$1.extname;
declare const relative: typeof path$1.relative;
declare const dirname: typeof path$1.dirname;
declare const format: typeof path$1.format;
declare const basename: typeof path$1.basename;
declare const parse: typeof path$1.parse;
declare const path_basename: typeof basename;
declare const path_delimiter: typeof delimiter;
declare const path_dirname: typeof dirname;
declare const path_extname: typeof extname;
declare const path_format: typeof format;
declare const path_isAbsolute: typeof isAbsolute;
declare const path_join: typeof join;
declare const path_normalize: typeof normalize;
declare const path_normalizeString: typeof normalizeString;
declare const path_parse: typeof parse;
declare const path_relative: typeof relative;
declare const path_resolve: typeof resolve;
declare const path_sep: typeof sep;
declare const path_toNamespacedPath: typeof toNamespacedPath;
declare namespace path {
export { path_basename as basename, path_delimiter as delimiter, path_dirname as dirname, path_extname as extname, path_format as format, path_isAbsolute as isAbsolute, path_join as join, path_normalize as normalize, path_normalizeString as normalizeString, path_parse as parse, path_relative as relative, path_resolve as resolve, path_sep as sep, path_toNamespacedPath as toNamespacedPath };
}
export { basename, path as default, delimiter, dirname, extname, format, isAbsolute, join, normalize, normalizeString, parse, relative, resolve, sep, toNamespacedPath };

36
Frontend-Learner/node_modules/externality/node_modules/pathe/dist/index.d.ts generated vendored Normal file
View file

@ -0,0 +1,36 @@
import path$1 from 'node:path';
declare const sep = "/";
declare const delimiter = ":";
declare const normalize: typeof path$1.normalize;
declare const join: typeof path$1.join;
declare const resolve: typeof path$1.resolve;
declare function normalizeString(path: string, allowAboveRoot: boolean): string;
declare const isAbsolute: typeof path$1.isAbsolute;
declare const toNamespacedPath: typeof path$1.toNamespacedPath;
declare const extname: typeof path$1.extname;
declare const relative: typeof path$1.relative;
declare const dirname: typeof path$1.dirname;
declare const format: typeof path$1.format;
declare const basename: typeof path$1.basename;
declare const parse: typeof path$1.parse;
declare const path_basename: typeof basename;
declare const path_delimiter: typeof delimiter;
declare const path_dirname: typeof dirname;
declare const path_extname: typeof extname;
declare const path_format: typeof format;
declare const path_isAbsolute: typeof isAbsolute;
declare const path_join: typeof join;
declare const path_normalize: typeof normalize;
declare const path_normalizeString: typeof normalizeString;
declare const path_parse: typeof parse;
declare const path_relative: typeof relative;
declare const path_resolve: typeof resolve;
declare const path_sep: typeof sep;
declare const path_toNamespacedPath: typeof toNamespacedPath;
declare namespace path {
export { path_basename as basename, path_delimiter as delimiter, path_dirname as dirname, path_extname as extname, path_format as format, path_isAbsolute as isAbsolute, path_join as join, path_normalize as normalize, path_normalizeString as normalizeString, path_parse as parse, path_relative as relative, path_resolve as resolve, path_sep as sep, path_toNamespacedPath as toNamespacedPath };
}
export { basename, path as default, delimiter, dirname, extname, format, isAbsolute, join, normalize, normalizeString, parse, relative, resolve, sep, toNamespacedPath };

1
Frontend-Learner/node_modules/externality/node_modules/pathe/dist/index.mjs generated vendored Normal file
View file

@ -0,0 +1 @@
export { h as basename, p as default, d as delimiter, f as dirname, e as extname, g as format, i as isAbsolute, j as join, a as normalize, b as normalizeString, k as parse, c as relative, r as resolve, s as sep, t as toNamespacedPath } from './shared/pathe.ff20891b.mjs';

238
Frontend-Learner/node_modules/externality/node_modules/pathe/dist/shared/pathe.1f0a373c.cjs generated vendored Normal file
View file

@ -0,0 +1,238 @@
'use strict';
const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
function normalizeWindowsPath(input = "") {
if (!input) {
return input;
}
return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
}
const _UNC_REGEX = /^[/\\]{2}/;
const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
const sep = "/";
const delimiter = ":";
const normalize = function(path) {
if (path.length === 0) {
return ".";
}
path = normalizeWindowsPath(path);
const isUNCPath = path.match(_UNC_REGEX);
const isPathAbsolute = isAbsolute(path);
const trailingSeparator = path[path.length - 1] === "/";
path = normalizeString(path, !isPathAbsolute);
if (path.length === 0) {
if (isPathAbsolute) {
return "/";
}
return trailingSeparator ? "./" : ".";
}
if (trailingSeparator) {
path += "/";
}
if (_DRIVE_LETTER_RE.test(path)) {
path += "/";
}
if (isUNCPath) {
if (!isPathAbsolute) {
return `//./${path}`;
}
return `//${path}`;
}
return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
};
const join = function(...arguments_) {
if (arguments_.length === 0) {
return ".";
}
let joined;
for (const argument of arguments_) {
if (argument && argument.length > 0) {
if (joined === void 0) {
joined = argument;
} else {
joined += `/${argument}`;
}
}
}
if (joined === void 0) {
return ".";
}
return normalize(joined.replace(/\/\/+/g, "/"));
};
function cwd() {
if (typeof process !== "undefined" && typeof process.cwd === "function") {
return process.cwd().replace(/\\/g, "/");
}
return "/";
}
const resolve = function(...arguments_) {
arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
let resolvedPath = "";
let resolvedAbsolute = false;
for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
const path = index >= 0 ? arguments_[index] : cwd();
if (!path || path.length === 0) {
continue;
}
resolvedPath = `${path}/${resolvedPath}`;
resolvedAbsolute = isAbsolute(path);
}
resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
return `/${resolvedPath}`;
}
return resolvedPath.length > 0 ? resolvedPath : ".";
};
function normalizeString(path, allowAboveRoot) {
let res = "";
let lastSegmentLength = 0;
let lastSlash = -1;
let dots = 0;
let char = null;
for (let index = 0; index <= path.length; ++index) {
if (index < path.length) {
char = path[index];
} else if (char === "/") {
break;
} else {
char = "/";
}
if (char === "/") {
if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) {
if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
if (res.length > 2) {
const lastSlashIndex = res.lastIndexOf("/");
if (lastSlashIndex === -1) {
res = "";
lastSegmentLength = 0;
} else {
res = res.slice(0, lastSlashIndex);
lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
}
lastSlash = index;
dots = 0;
continue;
} else if (res.length > 0) {
res = "";
lastSegmentLength = 0;
lastSlash = index;
dots = 0;
continue;
}
}
if (allowAboveRoot) {
res += res.length > 0 ? "/.." : "..";
lastSegmentLength = 2;
}
} else {
if (res.length > 0) {
res += `/${path.slice(lastSlash + 1, index)}`;
} else {
res = path.slice(lastSlash + 1, index);
}
lastSegmentLength = index - lastSlash - 1;
}
lastSlash = index;
dots = 0;
} else if (char === "." && dots !== -1) {
++dots;
} else {
dots = -1;
}
}
return res;
}
const isAbsolute = function(p) {
return _IS_ABSOLUTE_RE.test(p);
};
const toNamespacedPath = function(p) {
return normalizeWindowsPath(p);
};
const _EXTNAME_RE = /.(\.[^./]+)$/;
const extname = function(p) {
const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
return match && match[1] || "";
};
const relative = function(from, to) {
const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) {
return _to.join("/");
}
const _fromCopy = [..._from];
for (const segment of _fromCopy) {
if (_to[0] !== segment) {
break;
}
_from.shift();
_to.shift();
}
return [..._from.map(() => ".."), ..._to].join("/");
};
const dirname = function(p) {
const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
segments[0] += "/";
}
return segments.join("/") || (isAbsolute(p) ? "/" : ".");
};
const format = function(p) {
const segments = [p.root, p.dir, p.base ?? p.name + p.ext].filter(Boolean);
return normalizeWindowsPath(
p.root ? resolve(...segments) : segments.join("/")
);
};
const basename = function(p, extension) {
const lastSegment = normalizeWindowsPath(p).split("/").pop();
return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
};
const parse = function(p) {
const root = normalizeWindowsPath(p).split("/").shift() || "/";
const base = basename(p);
const extension = extname(base);
return {
root,
dir: dirname(p),
base,
ext: extension,
name: base.slice(0, base.length - extension.length)
};
};
const path = {
__proto__: null,
basename: basename,
delimiter: delimiter,
dirname: dirname,
extname: extname,
format: format,
isAbsolute: isAbsolute,
join: join,
normalize: normalize,
normalizeString: normalizeString,
parse: parse,
relative: relative,
resolve: resolve,
sep: sep,
toNamespacedPath: toNamespacedPath
};
exports.basename = basename;
exports.delimiter = delimiter;
exports.dirname = dirname;
exports.extname = extname;
exports.format = format;
exports.isAbsolute = isAbsolute;
exports.join = join;
exports.normalize = normalize;
exports.normalizeString = normalizeString;
exports.normalizeWindowsPath = normalizeWindowsPath;
exports.parse = parse;
exports.path = path;
exports.relative = relative;
exports.resolve = resolve;
exports.sep = sep;
exports.toNamespacedPath = toNamespacedPath;

221
Frontend-Learner/node_modules/externality/node_modules/pathe/dist/shared/pathe.ff20891b.mjs generated vendored Normal file
View file

@ -0,0 +1,221 @@
const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
function normalizeWindowsPath(input = "") {
if (!input) {
return input;
}
return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
}
const _UNC_REGEX = /^[/\\]{2}/;
const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
const sep = "/";
const delimiter = ":";
const normalize = function(path) {
if (path.length === 0) {
return ".";
}
path = normalizeWindowsPath(path);
const isUNCPath = path.match(_UNC_REGEX);
const isPathAbsolute = isAbsolute(path);
const trailingSeparator = path[path.length - 1] === "/";
path = normalizeString(path, !isPathAbsolute);
if (path.length === 0) {
if (isPathAbsolute) {
return "/";
}
return trailingSeparator ? "./" : ".";
}
if (trailingSeparator) {
path += "/";
}
if (_DRIVE_LETTER_RE.test(path)) {
path += "/";
}
if (isUNCPath) {
if (!isPathAbsolute) {
return `//./${path}`;
}
return `//${path}`;
}
return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
};
const join = function(...arguments_) {
if (arguments_.length === 0) {
return ".";
}
let joined;
for (const argument of arguments_) {
if (argument && argument.length > 0) {
if (joined === void 0) {
joined = argument;
} else {
joined += `/${argument}`;
}
}
}
if (joined === void 0) {
return ".";
}
return normalize(joined.replace(/\/\/+/g, "/"));
};
function cwd() {
if (typeof process !== "undefined" && typeof process.cwd === "function") {
return process.cwd().replace(/\\/g, "/");
}
return "/";
}
const resolve = function(...arguments_) {
arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
let resolvedPath = "";
let resolvedAbsolute = false;
for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
const path = index >= 0 ? arguments_[index] : cwd();
if (!path || path.length === 0) {
continue;
}
resolvedPath = `${path}/${resolvedPath}`;
resolvedAbsolute = isAbsolute(path);
}
resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
return `/${resolvedPath}`;
}
return resolvedPath.length > 0 ? resolvedPath : ".";
};
function normalizeString(path, allowAboveRoot) {
let res = "";
let lastSegmentLength = 0;
let lastSlash = -1;
let dots = 0;
let char = null;
for (let index = 0; index <= path.length; ++index) {
if (index < path.length) {
char = path[index];
} else if (char === "/") {
break;
} else {
char = "/";
}
if (char === "/") {
if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) {
if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
if (res.length > 2) {
const lastSlashIndex = res.lastIndexOf("/");
if (lastSlashIndex === -1) {
res = "";
lastSegmentLength = 0;
} else {
res = res.slice(0, lastSlashIndex);
lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
}
lastSlash = index;
dots = 0;
continue;
} else if (res.length > 0) {
res = "";
lastSegmentLength = 0;
lastSlash = index;
dots = 0;
continue;
}
}
if (allowAboveRoot) {
res += res.length > 0 ? "/.." : "..";
lastSegmentLength = 2;
}
} else {
if (res.length > 0) {
res += `/${path.slice(lastSlash + 1, index)}`;
} else {
res = path.slice(lastSlash + 1, index);
}
lastSegmentLength = index - lastSlash - 1;
}
lastSlash = index;
dots = 0;
} else if (char === "." && dots !== -1) {
++dots;
} else {
dots = -1;
}
}
return res;
}
const isAbsolute = function(p) {
return _IS_ABSOLUTE_RE.test(p);
};
const toNamespacedPath = function(p) {
return normalizeWindowsPath(p);
};
const _EXTNAME_RE = /.(\.[^./]+)$/;
const extname = function(p) {
const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
return match && match[1] || "";
};
const relative = function(from, to) {
const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) {
return _to.join("/");
}
const _fromCopy = [..._from];
for (const segment of _fromCopy) {
if (_to[0] !== segment) {
break;
}
_from.shift();
_to.shift();
}
return [..._from.map(() => ".."), ..._to].join("/");
};
const dirname = function(p) {
const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
segments[0] += "/";
}
return segments.join("/") || (isAbsolute(p) ? "/" : ".");
};
const format = function(p) {
const segments = [p.root, p.dir, p.base ?? p.name + p.ext].filter(Boolean);
return normalizeWindowsPath(
p.root ? resolve(...segments) : segments.join("/")
);
};
const basename = function(p, extension) {
const lastSegment = normalizeWindowsPath(p).split("/").pop();
return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
};
const parse = function(p) {
const root = normalizeWindowsPath(p).split("/").shift() || "/";
const base = basename(p);
const extension = extname(base);
return {
root,
dir: dirname(p),
base,
ext: extension,
name: base.slice(0, base.length - extension.length)
};
};
const path = {
__proto__: null,
basename: basename,
delimiter: delimiter,
dirname: dirname,
extname: extname,
format: format,
isAbsolute: isAbsolute,
join: join,
normalize: normalize,
normalizeString: normalizeString,
parse: parse,
relative: relative,
resolve: resolve,
sep: sep,
toNamespacedPath: toNamespacedPath
};
export { normalize as a, normalizeString as b, relative as c, delimiter as d, extname as e, dirname as f, format as g, basename as h, isAbsolute as i, join as j, parse as k, normalizeWindowsPath as n, path as p, resolve as r, sep as s, toNamespacedPath as t };

58
Frontend-Learner/node_modules/externality/node_modules/pathe/dist/utils.cjs generated vendored Normal file
View file

@ -0,0 +1,58 @@
'use strict';
const index = require('./shared/pathe.1f0a373c.cjs');
const pathSeparators = /* @__PURE__ */ new Set(["/", "\\", void 0]);
const normalizedAliasSymbol = Symbol.for("pathe:normalizedAlias");
function normalizeAliases(_aliases) {
if (_aliases[normalizedAliasSymbol]) {
return _aliases;
}
const aliases = Object.fromEntries(
Object.entries(_aliases).sort(([a], [b]) => _compareAliases(a, b))
);
for (const key in aliases) {
for (const alias in aliases) {
if (alias === key || key.startsWith(alias)) {
continue;
}
if (aliases[key].startsWith(alias) && pathSeparators.has(aliases[key][alias.length])) {
aliases[key] = aliases[alias] + aliases[key].slice(alias.length);
}
}
}
Object.defineProperty(aliases, normalizedAliasSymbol, {
value: true,
enumerable: false
});
return aliases;
}
function resolveAlias(path, aliases) {
const _path = index.normalizeWindowsPath(path);
aliases = normalizeAliases(aliases);
for (const [alias, to] of Object.entries(aliases)) {
if (!_path.startsWith(alias)) {
continue;
}
const _alias = hasTrailingSlash(alias) ? alias.slice(0, -1) : alias;
if (hasTrailingSlash(_path[_alias.length])) {
return index.join(to, _path.slice(alias.length));
}
}
return _path;
}
const FILENAME_RE = /(^|[/\\])([^/\\]+?)(?=(\.[^.]+)?$)/;
function filename(path) {
return path.match(FILENAME_RE)?.[2];
}
function _compareAliases(a, b) {
return b.split("/").length - a.split("/").length;
}
function hasTrailingSlash(path = "/") {
const lastChar = path[path.length - 1];
return lastChar === "/" || lastChar === "\\";
}
exports.filename = filename;
exports.normalizeAliases = normalizeAliases;
exports.resolveAlias = resolveAlias;

5
Frontend-Learner/node_modules/externality/node_modules/pathe/dist/utils.d.cts generated vendored Normal file
View file

@ -0,0 +1,5 @@
declare function normalizeAliases(_aliases: Record<string, string>): Record<string, string>;
declare function resolveAlias(path: string, aliases: Record<string, string>): string;
declare function filename(path: string): string;
export { filename, normalizeAliases, resolveAlias };

5
Frontend-Learner/node_modules/externality/node_modules/pathe/dist/utils.d.mts generated vendored Normal file
View file

@ -0,0 +1,5 @@
declare function normalizeAliases(_aliases: Record<string, string>): Record<string, string>;
declare function resolveAlias(path: string, aliases: Record<string, string>): string;
declare function filename(path: string): string;
export { filename, normalizeAliases, resolveAlias };

5
Frontend-Learner/node_modules/externality/node_modules/pathe/dist/utils.d.ts generated vendored Normal file
View file

@ -0,0 +1,5 @@
declare function normalizeAliases(_aliases: Record<string, string>): Record<string, string>;
declare function resolveAlias(path: string, aliases: Record<string, string>): string;
declare function filename(path: string): string;
export { filename, normalizeAliases, resolveAlias };

54
Frontend-Learner/node_modules/externality/node_modules/pathe/dist/utils.mjs generated vendored Normal file
View file

@ -0,0 +1,54 @@
import { n as normalizeWindowsPath, j as join } from './shared/pathe.ff20891b.mjs';
const pathSeparators = /* @__PURE__ */ new Set(["/", "\\", void 0]);
const normalizedAliasSymbol = Symbol.for("pathe:normalizedAlias");
function normalizeAliases(_aliases) {
if (_aliases[normalizedAliasSymbol]) {
return _aliases;
}
const aliases = Object.fromEntries(
Object.entries(_aliases).sort(([a], [b]) => _compareAliases(a, b))
);
for (const key in aliases) {
for (const alias in aliases) {
if (alias === key || key.startsWith(alias)) {
continue;
}
if (aliases[key].startsWith(alias) && pathSeparators.has(aliases[key][alias.length])) {
aliases[key] = aliases[alias] + aliases[key].slice(alias.length);
}
}
}
Object.defineProperty(aliases, normalizedAliasSymbol, {
value: true,
enumerable: false
});
return aliases;
}
function resolveAlias(path, aliases) {
const _path = normalizeWindowsPath(path);
aliases = normalizeAliases(aliases);
for (const [alias, to] of Object.entries(aliases)) {
if (!_path.startsWith(alias)) {
continue;
}
const _alias = hasTrailingSlash(alias) ? alias.slice(0, -1) : alias;
if (hasTrailingSlash(_path[_alias.length])) {
return join(to, _path.slice(alias.length));
}
}
return _path;
}
const FILENAME_RE = /(^|[/\\])([^/\\]+?)(?=(\.[^.]+)?$)/;
function filename(path) {
return path.match(FILENAME_RE)?.[2];
}
function _compareAliases(a, b) {
return b.split("/").length - a.split("/").length;
}
function hasTrailingSlash(path = "/") {
const lastChar = path[path.length - 1];
return lastChar === "/" || lastChar === "\\";
}
export { filename, normalizeAliases, resolveAlias };

48
Frontend-Learner/node_modules/externality/node_modules/pathe/package.json generated vendored Normal file
View file

@ -0,0 +1,48 @@
{
"name": "pathe",
"version": "1.1.2",
"description": "Universal filesystem path utils",
"repository": "unjs/pathe",
"license": "MIT",
"sideEffects": false,
"exports": {
".": {
"types": "./dist/index.d.ts",
"import": "./dist/index.mjs",
"require": "./dist/index.cjs"
},
"./utils": {
"types": "./dist/utils.d.ts",
"import": "./dist/utils.mjs",
"require": "./dist/utils.cjs"
}
},
"main": "./dist/index.cjs",
"types": "./dist/index.d.ts",
"files": [
"dist",
"utils.d.ts"
],
"devDependencies": {
"@types/node": "^20.10.8",
"@vitest/coverage-v8": "^1.1.3",
"changelogen": "^0.5.5",
"eslint": "^8.56.0",
"eslint-config-unjs": "^0.2.1",
"jiti": "^1.21.0",
"prettier": "^3.1.1",
"typescript": "^5.3.3",
"unbuild": "^2.0.0",
"vitest": "^1.1.3"
},
"packageManager": "pnpm@8.14.0",
"scripts": {
"build": "unbuild",
"dev": "vitest",
"lint": "eslint --ext .ts . && prettier -c src test",
"lint:fix": "eslint --cache --ext .ts,.js,.mjs,.cjs . --fix && prettier -c src test -w",
"release": "pnpm test && pnpm build && changelogen --release && pnpm publish && git push --follow-tags",
"test": "pnpm lint && vitest run --coverage",
"test:types": "tsc --noEmit"
}
}

1
Frontend-Learner/node_modules/externality/node_modules/pathe/utils.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export * from "./dist/utils";

55
Frontend-Learner/node_modules/externality/package.json generated vendored Normal file
View file

@ -0,0 +1,55 @@
{
"name": "externality",
"version": "1.0.2",
"repository": "unjs/externality",
"license": "MIT",
"sideEffects": false,
"exports": {
".": {
"require": "./dist/index.cjs",
"import": "./dist/index.mjs",
"types": "./dist/index.d.ts"
},
"./*": "./*"
},
"main": "./dist/index.cjs",
"module": "./dist/index.mjs",
"types": "./dist/index.d.ts",
"files": [
"dist"
],
"dependencies": {
"enhanced-resolve": "^5.14.1",
"mlly": "^1.3.0",
"pathe": "^1.1.1",
"ufo": "^1.1.2"
},
"devDependencies": {
"@types/node": "^20.2.5",
"@vitest/coverage-c8": "^0.31.1",
"allowlist": "^0.1.1",
"c8": "^7.14.0",
"eslint": "^8.41.0",
"eslint-config-unjs": "^0.1.0",
"rollup": "^3.23.0",
"standard-version": "^9.3.2",
"typescript": "^5.1.3",
"unbuild": "^1.2.1",
"vite": "^4.3.9",
"vitest": "^0.31.4",
"webpack": "^5.85.0"
},
"build": {
"externals": [
"rollup"
]
},
"packageManager": "pnpm@8.6.1",
"scripts": {
"build": "unbuild",
"dev": "vitest",
"lint": "eslint --ext .ts .",
"release": "pnpm test && standard-version && git push --follow-tags && pnpm publish",
"test": "pnpm lint && vitest run"
}
}