@flex-development/mlly 1.0.0-alpha.1 → 1.0.0-alpha.11

package/changelog.config.ts

@@ -0,0 +1,404 @@
+/**
+ * @file Changelog Configuration
+ * @module config/changelog
+ * @see https://github.com/conventional-changelog/conventional-changelog/tree/master/packages/conventional-changelog-conventionalcommits
+ * @see https://github.com/conventional-changelog/conventional-changelog/tree/master/packages/conventional-changelog-core
+ * @see https://github.com/conventional-changelog/conventional-changelog/tree/master/packages/conventional-changelog-writer
+ * @see https://github.com/conventional-changelog/conventional-changelog/tree/master/packages/conventional-commits-parser
+ * @see https://github.com/conventional-changelog/conventional-changelog/tree/master/packages/git-raw-commits
+ */
+
+import pathe from '@flex-development/pathe'
+import { CompareResult, isNIL } from '@flex-development/tutils'
+import addStream from 'add-stream'
+import conventionalChangelog from 'conventional-changelog'
+import type { Options } from 'conventional-changelog-core'
+import type {
+  CommitGroup,
+  GeneratedContext
+} from 'conventional-changelog-writer'
+import type { Commit, ICommit } from 'conventional-commits-parser'
+import dateformat from 'dateformat'
+import type mri from 'mri'
+import {
+  createReadStream,
+  createWriteStream,
+  readFileSync,
+  type ReadStream,
+  type WriteStream
+} from 'node:fs'
+import type { Readable } from 'node:stream'
+import sade from 'sade'
+import semver from 'semver'
+import tempfile from 'tempfile'
+import pkg from './package.json' assert { type: 'json' }
+
+/**
+ * CLI flags.
+ */
+interface Flags {
+  /**
+   * Output unreleased changelog.
+   *
+   * To the set the current version, pass a string value.
+   *
+   * @example
+   *  '1.0.0-alpha.7'
+   * @example
+   *  true
+   *
+   * @default true
+   */
+  'output-unreleased'?: boolean | string
+
+  /**
+   * Number of releases to be generated.
+   *
+   * If `0`, the changelog will be regenerated and the output file will be
+   * overwritten.
+   *
+   * @default 1
+   */
+  'release-count'?: number
+
+  /**
+   * Output content to {@linkcode infile}.
+   *
+   * @default false
+   */
+  'same-file'?: boolean
+
+  /**
+   * Enable verbose output.
+   *
+   * @default false
+   */
+  debug?: boolean
+
+  /**
+   * Read CHANGELOG from this file.
+   */
+  infile?: string
+
+  /**
+   * Write content to this file.
+   *
+   * **Note**: Requires {@linkcode write} to be `true`.
+   */
+  outfile?: string
+
+  /**
+   * Write content to file instead of {@linkcode process.stdout}.
+   *
+   * @default false
+   */
+  write?: boolean
+}
+
+sade('changelog', true)
+  .option('-d, --debug', 'Enable verbose output', false)
+  .option('-i, --infile', 'Read CHANGELOG from this file')
+  .option('-o, --outfile', 'Write content to this file (requires --write)')
+  .option('-r, --release-count', 'Number of releases to be generated', 1)
+  .option('-s, --same-file', 'Output content to infile', false)
+  .option('-u, --output-unreleased', 'Output unreleased changelog')
+  .option('-w, --write', 'Write content to file', false)
+  .action((flags: mri.Argv<Flags>): void => {
+    const {
+      'release-count': releaseCount = 1,
+      debug = false,
+      write = false
+    } = flags
+    let {
+      'output-unreleased': outputUnreleased = true,
+      infile,
+      'same-file': samefile,
+      outfile
+    } = flags
+
+    // convert possible 'false' or 'true' to boolean value
+    if (outputUnreleased === 'false' || outputUnreleased === 'true') {
+      outputUnreleased = JSON.parse(outputUnreleased)
+    }
+
+    /**
+     * Regex used to extract a release version from a string containing
+     * Git tags.
+     *
+     * @const {RegExp} vgx
+     */
+    const vgx: RegExp = pkg.tagPrefix
+      ? new RegExp(`tag:\\s*[=]?${pkg.tagPrefix}(.+?)[,)]`, 'gi')
+      : /tag:\s*[=v]?(.+?)[),]/gi
+
+    /**
+     * Changelog content stream.
+     *
+     * @const {Readable} changelog
+     */
+    const changelog: Readable = conventionalChangelog(
+      {
+        append: false,
+        debug: debug ? console.debug.bind(console) : undefined,
+        outputUnreleased:
+          typeof outputUnreleased === 'boolean'
+            ? outputUnreleased
+            : typeof outputUnreleased === 'string'
+            ? !!outputUnreleased.trim()
+            : false,
+        pkg: { path: pathe.resolve('package.json') },
+        // @ts-expect-error ts(2322)
+        preset: {
+          header: '',
+          name: 'conventionalcommits',
+          releaseCommitMessageFormat: 'release: {{currentTag}}',
+          types: [
+            { section: ':package: Build', type: 'build' },
+            { section: ':house_with_garden: Housekeeping', type: 'chore' },
+            { section: ':robot: Continuous Integration', type: 'ci' },
+            { section: ':pencil: Documentation', type: 'docs' },
+            { section: ':sparkles: Features', type: 'feat' },
+            { section: ':bug: Fixes', type: 'fix' },
+            { section: ':fire: Performance Improvements', type: 'perf' },
+            { section: ':zap: Refactors', type: 'refactor' },
+            { section: ':rewind: Reverts', type: 'revert' },
+            { hidden: true, type: 'style' },
+            { section: ':white_check_mark: Testing', type: 'test' },
+            { hidden: true, type: 'wip' }
+          ]
+        },
+        releaseCount,
+        skipUnstable: false,
+        tagPrefix: pkg.tagPrefix,
+        /**
+         * Raw commit transformer.
+         *
+         * @see https://github.com/conventional-changelog/conventional-changelog/tree/master/packages/conventional-changelog-core#transform-1
+         * @see https://github.com/conventional-changelog/conventional-changelog/issues/415
+         *
+         * @param {Commit} commit - Commit object
+         * @param {Options.Transform.Callback} apply - Commit handler
+         * @return {void} Nothing when complete
+         */
+        transform(commit: Commit, apply: Options.Transform.Callback): void {
+          return void apply(null, {
+            ...commit,
+            committerDate: dateformat(
+              commit.committerDate!,
+              'yyyy-mm-dd',
+              true
+            ),
+            mentions: commit.mentions.filter(m => m !== 'flexdevelopment'),
+            // @ts-expect-error ts(2322)
+            raw: commit,
+            references: commit.references.filter(ref => ref.action !== null),
+            shortHash: commit.hash!.slice(0, 7),
+            version: commit.gitTags ? vgx.exec(commit.gitTags)?.[1] : undefined
+          })
+        }
+      },
+      {},
+      {},
+      {
+        issuePrefixesCaseSensitive: true
+      },
+      {
+        /**
+         * Sorts commit groups in descending order by group title.
+         *
+         * GitHub emojis in titles will be ignored.
+         *
+         * @see https://github.com/conventional-changelog/conventional-changelog/tree/master/packages/conventional-changelog-writer#commitgroupssort
+         *
+         * @param {CommitGroup} a - Commit group object
+         * @param {CommitGroup} b - Commit group object to compare to `a`
+         * @return {number} Compare result
+         */
+        commitGroupsSort(a: CommitGroup, b: CommitGroup): number {
+          if (a.title === false) return CompareResult.GREATER_THAN
+          if (b.title === false) return CompareResult.LESS_THAN
+
+          /**
+           * Regex used to extract commit group titles without GitHub emojis.
+           *
+           * @const {RegExp} tgx - Regex used to extract commit group title
+           */
+          const tgx: RegExp = /([A-Z])\w+/
+
+          return tgx.exec(a.title)![0]!.localeCompare(tgx.exec(b.title)![0]!)
+        },
+        /**
+         * Sorts commits in descending order by commit header and date.
+         *
+         * @see https://github.com/conventional-changelog/conventional-changelog/tree/master/packages/conventional-changelog-writer#commitssort
+         *
+         * @param {ICommit} a - Commit object
+         * @param {ICommit} b - Commit object to compare to `b`
+         * @return {number} Compare result
+         */
+        commitsSort(a: ICommit, b: ICommit): number {
+          /**
+           * Compare result for {@linkcode b.committerDate} and
+           * {@linkcode a.committerDate}.
+           *
+           * @const {number} by_date
+           */
+          const by_date: number =
+            new Date(b.committerDate).getTime() -
+            new Date(a.committerDate).getTime()
+
+          return a.header && b.header
+            ? a.header.localeCompare(b.header) || by_date
+            : by_date
+        },
+        /**
+         * Modifies `context` before the changelog is generated.
+         *
+         * This includes:
+         *
+         * - Setting the current and previous release tags
+         * - Setting the release date
+         * - Determining patch release state
+         * - Determining if compare links should be generated
+         *
+         * @see https://github.com/conventional-changelog/conventional-changelog/tree/master/packages/conventional-changelog-core#finalizecontext
+         * @see https://github.com/conventional-changelog/conventional-changelog/tree/master/packages/conventional-changelog-writer#finalizecontext
+         *
+         * @param {GeneratedContext} context - Generated changelog context
+         * @param {Options} options - `conventional-changelog-core` options
+         * @param {ICommit[]} commits - Commits for release
+         * @param {ICommit | undefined} key - Release commit
+         * @return {GeneratedContext} Final changelog context
+         */
+        finalizeContext(
+          context: GeneratedContext,
+          options: Options,
+          commits: ICommit[],
+          key: ICommit | undefined
+        ): GeneratedContext {
+          const { gitSemverTags = [], isPatch, linkCompare, version } = context
+          let { currentTag, previousTag } = context
+
+          /**
+           * First commit in release.
+           *
+           * @const {ICommit | undefined} first_commit
+           */
+          const first_commit: ICommit | undefined = commits.at(0)
+
+          /**
+           * Last commit in release.
+           *
+           * @const {ICommit | undefined} last_commit
+           */
+          const last_commit: ICommit | undefined = commits.at(-1)
+
+          // set current and previous tags
+          if (key && (!currentTag || !previousTag)) {
+            currentTag = key.version ?? undefined
+
+            // try setting previous tag based on current tag
+            if (gitSemverTags.includes(currentTag ?? '')) {
+              const { version } = key
+              previousTag = gitSemverTags[gitSemverTags.indexOf(version!) + 1]
+              if (!previousTag) previousTag = last_commit?.hash ?? undefined
+            }
+          } else {
+            currentTag = /^unreleased$/i.test(version ?? '')
+              ? currentTag ??
+                (typeof outputUnreleased === 'string' && outputUnreleased
+                  ? outputUnreleased
+                  : first_commit?.hash ?? undefined)
+              : !currentTag && version
+              ? pkg.tagPrefix + version
+              : currentTag ?? version
+            previousTag = previousTag ?? gitSemverTags[0]
+          }
+
+          // set release date
+          context.date =
+            key?.committerDate ?? dateformat(new Date(), 'yyyy-mm-dd', true)
+
+          // determine patch release state
+          if (version && semver.valid(version)) {
+            context.isPatch = isPatch ?? semver.patch(version) !== 0
+          }
+
+          // @ts-expect-error ts(2322)
+          return {
+            ...context,
+            currentTag,
+            linkCompare: isNIL(linkCompare) && !!currentTag && !!previousTag,
+            previousTag,
+            repoUrl: pkg.repository.slice(0, -4)
+          }
+        },
+        headerPartial: readFileSync('templates/changelog/header.hbs', 'utf8'),
+        ignoreReverted: false
+      }
+    ).on('error', err => console.error(err.stack))
+
+    // override samefile if infile and outfile are the same file
+    if (infile && infile === outfile) samefile = true
+
+    // reset outfile if changelog should be output to infile
+    if (samefile) outfile = infile = infile ?? 'CHANGELOG.md'
+
+    /**
+     * Creates a file writer.
+     *
+     * If writing to file is disabled, {@linkcode process.stdout} will be used
+     * to write content to the terminal.
+     *
+     * Otherwise, {@linkcode createWriteStream} will be used to create a stream
+     * for {@linkcode outfile}.
+     *
+     * @see {@linkcode NodeJS.WriteStream}
+     * @see {@linkcode WriteStream}
+     * @see {@linkcode createWriteStream}
+     *
+     * @return {WriteStream | (NodeJS.WriteStream & { fd: 1 })} File writer
+     */
+    const writer = (): WriteStream | (NodeJS.WriteStream & { fd: 1 }) => {
+      return write && outfile ? createWriteStream(outfile) : process.stdout
+    }
+
+    // write changelog to infile, outfile, or stdout
+    switch (true) {
+      case infile && releaseCount !== 0:
+        /**
+         * Changelog file stream.
+         *
+         * @const {ReadStream} rs
+         */
+        const rs: ReadStream = createReadStream(infile!).on('error', () => {
+          if (debug) console.error('infile does not exist.')
+          if (samefile) changelog.pipe(writer())
+        })
+
+        // write changelog to infile or stdout
+        if (samefile) {
+          /**
+           * Absolute path to random temporary file.
+           *
+           * @const {string} tmp
+           */
+          const tmp: string = tempfile()
+
+          changelog
+            .pipe(addStream(rs))
+            .pipe(createWriteStream(tmp))
+            .on('finish', () => createReadStream(tmp).pipe(writer()))
+        } else {
+          changelog.pipe(addStream(rs)).pipe(writer())
+        }
+
+        break
+      default:
+        changelog.pipe(writer())
+        break
+    }
+
+    return void 0
+  })
+  .parse(process.argv)

package/dist/enums/assert-type.d.mts

@@ -0,0 +1,21 @@
+/**
+ * @file Enums - AssertType
+ * @module mlly/enums/AssertType
+ */
+/**
+ * `import` assertion types.
+ *
+ * ::: info
+ * It's unclear whether or not the HTML spec will require assertion types for
+ * WebAssembly modules.
+ * :::
+ *
+ * @see https://github.com/WebAssembly/esm-integration/issues/42
+ *
+ * @enum {Lowercase<string>}
+ */
+declare enum AssertType {
+    IMPLICIT = "javascript",
+    JSON = "json"
+}
+export default AssertType;

package/dist/enums/assert-type.mjs

@@ -0,0 +1,10 @@
+var AssertType = /* @__PURE__ */ ((AssertType2) => {
+  AssertType2["IMPLICIT"] = "javascript";
+  AssertType2["JSON"] = "json";
+  return AssertType2;
+})(AssertType || {});
+var assert_type_default = AssertType;
+export {
+  assert_type_default as default
+};
+//# sourceMappingURL=assert-type.mjs.map

package/dist/enums/assert-type.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/enums/assert-type.ts"],
+  "mappings": "AAiBA,IAAK,aAAL,kBAAKA,gBAAL;AACE,EAAAA,YAAA,cAAW;AACX,EAAAA,YAAA,UAAO;AAFJ,SAAAA;AAAA,GAAA;AAKL,IAAO,sBAAQ;",
+  "names": ["AssertType"]
+}

package/dist/enums/format.d.mts

@@ -0,0 +1,17 @@
+/**
+ * @file Enums - Format
+ * @module mlly/enums/Format
+ */
+/**
+ * Module formats.
+ *
+ * @enum {Lowercase<string>}
+ */
+declare enum Format {
+    BUILTIN = "builtin",
+    COMMONJS = "commonjs",
+    JSON = "json",
+    MODULE = "module",
+    WASM = "wasm"
+}
+export default Format;

package/dist/enums/format.mjs

@@ -0,0 +1,13 @@
+var Format = /* @__PURE__ */ ((Format2) => {
+  Format2["BUILTIN"] = "builtin";
+  Format2["COMMONJS"] = "commonjs";
+  Format2["JSON"] = "json";
+  Format2["MODULE"] = "module";
+  Format2["WASM"] = "wasm";
+  return Format2;
+})(Format || {});
+var format_default = Format;
+export {
+  format_default as default
+};
+//# sourceMappingURL=format.mjs.map

package/dist/enums/format.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/enums/format.ts"],
+  "mappings": "AAUA,IAAK,SAAL,kBAAKA,YAAL;AACE,EAAAA,QAAA,aAAU;AACV,EAAAA,QAAA,cAAW;AACX,EAAAA,QAAA,UAAO;AACP,EAAAA,QAAA,YAAS;AACT,EAAAA,QAAA,UAAO;AALJ,SAAAA;AAAA,GAAA;AAQL,IAAO,iBAAQ;",
+  "names": ["Format"]
+}

package/dist/enums/index.d.mts

@@ -0,0 +1,10 @@
+/**
+ * @file Entry Point - Enums
+ * @module mlly/enums
+ */
+export { default as AssertType } from './assert-type.mjs';
+export { default as Format } from './format.mjs';
+export { default as SpecifierKind } from './kind-specifier.mjs';
+export { default as SpecifierSyntaxKind } from './kind-specifier-syntax.mjs';
+export { default as StatementKind } from './kind-statement.mjs';
+export { default as StatementSyntaxKind } from './kind-statement-syntax.mjs';

package/dist/enums/index.mjs

@@ -0,0 +1,15 @@
+import { default as default2 } from "./assert-type.mjs";
+import { default as default3 } from "./format.mjs";
+import { default as default4 } from "./kind-specifier.mjs";
+import { default as default5 } from "./kind-specifier-syntax.mjs";
+import { default as default6 } from "./kind-statement.mjs";
+import { default as default7 } from "./kind-statement-syntax.mjs";
+export {
+  default2 as AssertType,
+  default3 as Format,
+  default4 as SpecifierKind,
+  default5 as SpecifierSyntaxKind,
+  default6 as StatementKind,
+  default7 as StatementSyntaxKind
+};
+//# sourceMappingURL=index.mjs.map

package/dist/enums/index.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/enums/index.ts"],
+  "mappings": "AAKA,SAAoB,WAAXA,gBAA6B;AACtC,SAAoB,WAAXA,gBAAyB;AAClC,SAAoB,WAAXA,gBAAgC;AACzC,SAAoB,WAAXA,gBAAsC;AAC/C,SAAoB,WAAXA,gBAAgC;AACzC,SAAoB,WAAXA,gBAAsC;",
+  "names": ["default"]
+}

package/dist/enums/kind-specifier-syntax.d.mts

@@ -0,0 +1,14 @@
+/**
+ * @file Enums - SpecifierSyntaxKind
+ * @module mlly/enums/SpecifierSyntaxKind
+ */
+/**
+ * Module specifier syntax types.
+ *
+ * @enum {Lowercase<string>}
+ */
+declare enum SpecifierSyntaxKind {
+    DYNAMIC = "dynamic",
+    STATIC = "static"
+}
+export default SpecifierSyntaxKind;

package/dist/enums/kind-specifier-syntax.mjs

@@ -0,0 +1,10 @@
+var SpecifierSyntaxKind = /* @__PURE__ */ ((SpecifierSyntaxKind2) => {
+  SpecifierSyntaxKind2["DYNAMIC"] = "dynamic";
+  SpecifierSyntaxKind2["STATIC"] = "static";
+  return SpecifierSyntaxKind2;
+})(SpecifierSyntaxKind || {});
+var kind_specifier_syntax_default = SpecifierSyntaxKind;
+export {
+  kind_specifier_syntax_default as default
+};
+//# sourceMappingURL=kind-specifier-syntax.mjs.map

package/dist/enums/kind-specifier-syntax.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/enums/kind-specifier-syntax.ts"],
+  "mappings": "AAUA,IAAK,sBAAL,kBAAKA,yBAAL;AACE,EAAAA,qBAAA,aAAU;AACV,EAAAA,qBAAA,YAAS;AAFN,SAAAA;AAAA,GAAA;AAKL,IAAO,gCAAQ;",
+  "names": ["SpecifierSyntaxKind"]
+}

package/dist/enums/kind-specifier.d.mts

@@ -0,0 +1,17 @@
+/**
+ * @file Enums - SpecifierKind
+ * @module mlly/enums/SpecifierKind
+ */
+/**
+ * Module specifier types.
+ *
+ * @see https://nodejs.org/api/esm.html#terminology
+ *
+ * @enum {Lowercase<string>}
+ */
+declare enum SpecifierKind {
+    ABSOLUTE = "absolute",
+    BARE = "bare",
+    RELATIVE = "relative"
+}
+export default SpecifierKind;

package/dist/enums/kind-specifier.mjs

@@ -0,0 +1,11 @@
+var SpecifierKind = /* @__PURE__ */ ((SpecifierKind2) => {
+  SpecifierKind2["ABSOLUTE"] = "absolute";
+  SpecifierKind2["BARE"] = "bare";
+  SpecifierKind2["RELATIVE"] = "relative";
+  return SpecifierKind2;
+})(SpecifierKind || {});
+var kind_specifier_default = SpecifierKind;
+export {
+  kind_specifier_default as default
+};
+//# sourceMappingURL=kind-specifier.mjs.map

package/dist/enums/kind-specifier.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/enums/kind-specifier.ts"],
+  "mappings": "AAYA,IAAK,gBAAL,kBAAKA,mBAAL;AACE,EAAAA,eAAA,cAAW;AACX,EAAAA,eAAA,UAAO;AACP,EAAAA,eAAA,cAAW;AAHR,SAAAA;AAAA,GAAA;AAML,IAAO,yBAAQ;",
+  "names": ["SpecifierKind"]
+}

package/dist/enums/kind-statement-syntax.d.mts

@@ -0,0 +1,22 @@
+/**
+ * @file Enums - StatementSyntaxKind
+ * @module mlly/enums/StatementSyntaxKind
+ */
+/**
+ * CommonJS and ESM statement syntax kinds.
+ *
+ * @enum {Lowercase<string>}
+ */
+declare enum StatementSyntaxKind {
+    DECLARATION = "declaration",
+    DEFAULT = "default",
+    DEFAULT_WITH_NAMED = "default-with-named",
+    DEFAULT_WITH_NAMESPACE = "default-with-namespace",
+    DYNAMIC = "dynamic",
+    LIST = "list",
+    NAMED = "named",
+    NAMESPACE = "namespace",
+    REQUIRE = "require",
+    SIDE_EFFECT = "side-effect"
+}
+export default StatementSyntaxKind;

package/dist/enums/kind-statement-syntax.mjs

@@ -0,0 +1,18 @@
+var StatementSyntaxKind = /* @__PURE__ */ ((StatementSyntaxKind2) => {
+  StatementSyntaxKind2["DECLARATION"] = "declaration";
+  StatementSyntaxKind2["DEFAULT"] = "default";
+  StatementSyntaxKind2["DEFAULT_WITH_NAMED"] = "default-with-named";
+  StatementSyntaxKind2["DEFAULT_WITH_NAMESPACE"] = "default-with-namespace";
+  StatementSyntaxKind2["DYNAMIC"] = "dynamic";
+  StatementSyntaxKind2["LIST"] = "list";
+  StatementSyntaxKind2["NAMED"] = "named";
+  StatementSyntaxKind2["NAMESPACE"] = "namespace";
+  StatementSyntaxKind2["REQUIRE"] = "require";
+  StatementSyntaxKind2["SIDE_EFFECT"] = "side-effect";
+  return StatementSyntaxKind2;
+})(StatementSyntaxKind || {});
+var kind_statement_syntax_default = StatementSyntaxKind;
+export {
+  kind_statement_syntax_default as default
+};
+//# sourceMappingURL=kind-statement-syntax.mjs.map

package/dist/enums/kind-statement-syntax.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/enums/kind-statement-syntax.ts"],
+  "mappings": "AAUA,IAAK,sBAAL,kBAAKA,yBAAL;AACE,EAAAA,qBAAA,iBAAc;AACd,EAAAA,qBAAA,aAAU;AACV,EAAAA,qBAAA,wBAAqB;AACrB,EAAAA,qBAAA,4BAAyB;AACzB,EAAAA,qBAAA,aAAU;AACV,EAAAA,qBAAA,UAAO;AACP,EAAAA,qBAAA,WAAQ;AACR,EAAAA,qBAAA,eAAY;AACZ,EAAAA,qBAAA,aAAU;AACV,EAAAA,qBAAA,iBAAc;AAVX,SAAAA;AAAA,GAAA;AAaL,IAAO,gCAAQ;",
+  "names": ["StatementSyntaxKind"]
+}

package/dist/enums/kind-statement.d.mts

@@ -0,0 +1,15 @@
+/**
+ * @file Enums - StatementKind
+ * @module mlly/enums/StatementKind
+ */
+/**
+ * CommonJS and ESM statement kinds.
+ *
+ * @enum {Lowercase<string>}
+ */
+declare enum StatementKind {
+    EXPORT = "export",
+    IMPORT = "import",
+    REQUIRE = "require"
+}
+export default StatementKind;

package/dist/enums/kind-statement.mjs

@@ -0,0 +1,11 @@
+var StatementKind = /* @__PURE__ */ ((StatementKind2) => {
+  StatementKind2["EXPORT"] = "export";
+  StatementKind2["IMPORT"] = "import";
+  StatementKind2["REQUIRE"] = "require";
+  return StatementKind2;
+})(StatementKind || {});
+var kind_statement_default = StatementKind;
+export {
+  kind_statement_default as default
+};
+//# sourceMappingURL=kind-statement.mjs.map