eslint-plugin-perfectionist 4.1.2 → 4.3.0

package/dist/rules/sort-objects.js

@@ -2,7 +2,9 @@
 const commonJsonSchemas = require('../utils/common-json-schemas.js')
 const sortNodesByDependencies = require('../utils/sort-nodes-by-dependencies.js')
 const validateNewlinesAndPartitionConfiguration = require('../utils/validate-newlines-and-partition-configuration.js')
+const validateCustomSortConfiguration = require('../utils/validate-custom-sort-configuration.js')
 const validateGroupsConfiguration = require('../utils/validate-groups-configuration.js')
+const getMatchingContextOptions = require('../utils/get-matching-context-options.js')
 const getEslintDisabledLines = require('../utils/get-eslint-disabled-lines.js')
 const isNodeEslintDisabled = require('../utils/is-node-eslint-disabled.js')
 const isPartitionComment = require('../utils/is-partition-comment.js')
@@ -33,11 +35,13 @@ let defaultOptions = {
   objectDeclarations: true,
   styledComponents: true,
   destructureOnly: false,
+  useConfigurationIf: {},
   type: 'alphabetical',
   ignorePattern: [],
   ignoreCase: true,
   customGroups: {},
   locales: 'en-US',
+  alphabet: '',
   order: 'asc',
   groups: [],
 }
@@ -48,11 +52,20 @@ const sortObjects = createEslintRule.createEslintRule({
         return
       }
       let settings = getSettings.getSettings(context.settings)
+      let sourceCode = getSourceCode.getSourceCode(context)
+      let matchedContextOptions =
+        getMatchingContextOptions.getMatchingContextOptions({
+          nodeNames: nodeObject.properties
+            .map(property => getNodeName({ sourceCode, property }))
+            .filter(nodeName => nodeName !== null),
+          contextOptions: context.options,
+        })
       let options = complete.complete(
-        context.options.at(0),
+        matchedContextOptions,
         settings,
         defaultOptions,
       )
+      validateCustomSortConfiguration.validateCustomSortConfiguration(options)
       validateGroupsConfiguration.validateGroupsConfiguration(
         options.groups,
         ['multiline', 'method', 'unknown'],
@@ -130,7 +143,6 @@ const sortObjects = createEslintRule.createEslintRule({
       ) {
         return
       }
-      let sourceCode = getSourceCode.getSourceCode(context)
       let eslintDisabledLines = getEslintDisabledLines.getEslintDisabledLines({
         ruleName: context.id,
         sourceCode,
@@ -218,10 +230,6 @@ const sortObjects = createEslintRule.createEslintRule({
               accumulator.push([])
               return accumulator
             }
-            let comments = getCommentsBefore.getCommentsBefore(
-              property,
-              sourceCode,
-            )
             let lastProperty =
               (_a = accumulator.at(-1)) == null ? void 0 : _a.at(-1)
             let name
@@ -270,7 +278,10 @@ const sortObjects = createEslintRule.createEslintRule({
               (options.partitionByComment &&
                 isPartitionComment.hasPartitionComment(
                   options.partitionByComment,
-                  comments,
+                  getCommentsBefore.getCommentsBefore({
+                    node: property,
+                    sourceCode,
+                  }),
                 ))
             ) {
               accumulator.push([])
@@ -383,8 +394,8 @@ const sortObjects = createEslintRule.createEslintRule({
     }
   },
   meta: {
-    schema: [
-      {
+    schema: {
+      items: {
         properties: {
           destructuredObjects: {
             oneOf: [
@@ -431,10 +442,12 @@ const sortObjects = createEslintRule.createEslintRule({
             type: 'boolean',
           },
           partitionByNewLine: commonJsonSchemas.partitionByNewLineJsonSchema,
+          useConfigurationIf: commonJsonSchemas.useConfigurationIfJsonSchema,
           specialCharacters: commonJsonSchemas.specialCharactersJsonSchema,
           newlinesBetween: commonJsonSchemas.newlinesBetweenJsonSchema,
           customGroups: commonJsonSchemas.customGroupsJsonSchema,
           ignoreCase: commonJsonSchemas.ignoreCaseJsonSchema,
+          alphabet: commonJsonSchemas.alphabetJsonSchema,
           locales: commonJsonSchemas.localesJsonSchema,
           groups: commonJsonSchemas.groupsJsonSchema,
           order: commonJsonSchemas.orderJsonSchema,
@@ -443,7 +456,9 @@ const sortObjects = createEslintRule.createEslintRule({
         additionalProperties: false,
         type: 'object',
       },
-    ],
+      uniqueItems: true,
+      type: 'array',
+    },
     messages: {
       unexpectedObjectsGroupOrder:
         'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
@@ -466,4 +481,15 @@ const sortObjects = createEslintRule.createEslintRule({
   defaultOptions: [defaultOptions],
   name: 'sort-objects',
 })
+let getNodeName = ({ sourceCode, property }) => {
+  if (property.type === 'SpreadElement' || property.type === 'RestElement') {
+    return null
+  }
+  if (property.key.type === 'Identifier') {
+    return property.key.name
+  } else if (property.key.type === 'Literal') {
+    return `${property.key.value}`
+  }
+  return sourceCode.getText(property.key)
+}
 module.exports = sortObjects

package/dist/rules/sort-switch-case.js

@@ -1,5 +1,6 @@
 'use strict'
 const commonJsonSchemas = require('../utils/common-json-schemas.js')
+const validateCustomSortConfiguration = require('../utils/validate-custom-sort-configuration.js')
 const makeCommentAfterFixes = require('../utils/make-comment-after-fixes.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
 const getSourceCode = require('../utils/get-source-code.js')
@@ -16,6 +17,7 @@ let defaultOptions = {
   type: 'alphabetical',
   ignoreCase: true,
   locales: 'en-US',
+  alphabet: '',
   order: 'asc',
 }
 const sortSwitchCase = createEslintRule.createEslintRule({
@@ -30,6 +32,7 @@ const sortSwitchCase = createEslintRule.createEslintRule({
         settings,
         defaultOptions,
       )
+      validateCustomSortConfiguration.validateCustomSortConfiguration(options)
       let sourceCode = getSourceCode.getSourceCode(context)
       let isDiscriminantTrue =
         switchNode.discriminant.type === 'Literal' &&
@@ -218,6 +221,7 @@ const sortSwitchCase = createEslintRule.createEslintRule({
         properties: {
           specialCharacters: commonJsonSchemas.specialCharactersJsonSchema,
           ignoreCase: commonJsonSchemas.ignoreCaseJsonSchema,
+          alphabet: commonJsonSchemas.alphabetJsonSchema,
           locales: commonJsonSchemas.localesJsonSchema,
           order: commonJsonSchemas.orderJsonSchema,
           type: commonJsonSchemas.typeJsonSchema,

package/dist/rules/sort-union-types.js

@@ -1,6 +1,7 @@
 'use strict'
 const commonJsonSchemas = require('../utils/common-json-schemas.js')
 const validateNewlinesAndPartitionConfiguration = require('../utils/validate-newlines-and-partition-configuration.js')
+const validateCustomSortConfiguration = require('../utils/validate-custom-sort-configuration.js')
 const validateGroupsConfiguration = require('../utils/validate-groups-configuration.js')
 const getEslintDisabledLines = require('../utils/get-eslint-disabled-lines.js')
 const isNodeEslintDisabled = require('../utils/is-node-eslint-disabled.js')
@@ -28,6 +29,7 @@ let defaultOptions = {
   type: 'alphabetical',
   ignoreCase: true,
   locales: 'en-US',
+  alphabet: '',
   order: 'asc',
   groups: [],
 }
@@ -40,6 +42,7 @@ const sortUnionTypes = createEslintRule.createEslintRule({
         settings,
         defaultOptions,
       )
+      validateCustomSortConfiguration.validateCustomSortConfiguration(options)
       validateGroupsConfiguration.validateGroupsConfiguration(
         options.groups,
         [
@@ -144,7 +147,11 @@ const sortUnionTypes = createEslintRule.createEslintRule({
             (options.partitionByComment &&
               isPartitionComment.hasPartitionComment(
                 options.partitionByComment,
-                getCommentsBefore.getCommentsBefore(type, sourceCode, '|'),
+                getCommentsBefore.getCommentsBefore({
+                  tokenValueToIgnoreBefore: '|',
+                  node: type,
+                  sourceCode,
+                }),
               )) ||
             (options.partitionByNewLine &&
               lastSortingNode &&
@@ -245,6 +252,7 @@ const sortUnionTypes = createEslintRule.createEslintRule({
           specialCharacters: commonJsonSchemas.specialCharactersJsonSchema,
           newlinesBetween: commonJsonSchemas.newlinesBetweenJsonSchema,
           ignoreCase: commonJsonSchemas.ignoreCaseJsonSchema,
+          alphabet: commonJsonSchemas.alphabetJsonSchema,
           locales: commonJsonSchemas.localesJsonSchema,
           groups: commonJsonSchemas.groupsJsonSchema,
           order: commonJsonSchemas.orderJsonSchema,

package/dist/rules/sort-variable-declarations.js

@@ -1,6 +1,7 @@
 'use strict'
 const commonJsonSchemas = require('../utils/common-json-schemas.js')
 const sortNodesByDependencies = require('../utils/sort-nodes-by-dependencies.js')
+const validateCustomSortConfiguration = require('../utils/validate-custom-sort-configuration.js')
 const getEslintDisabledLines = require('../utils/get-eslint-disabled-lines.js')
 const isNodeEslintDisabled = require('../utils/is-node-eslint-disabled.js')
 const isPartitionComment = require('../utils/is-partition-comment.js')
@@ -23,6 +24,7 @@ let defaultOptions = {
   type: 'alphabetical',
   ignoreCase: true,
   locales: 'en-US',
+  alphabet: '',
   order: 'asc',
 }
 const sortVariableDeclarations = createEslintRule.createEslintRule({
@@ -37,6 +39,7 @@ const sortVariableDeclarations = createEslintRule.createEslintRule({
         settings,
         defaultOptions,
       )
+      validateCustomSortConfiguration.validateCustomSortConfiguration(options)
       let sourceCode = getSourceCode.getSourceCode(context)
       let eslintDisabledLines = getEslintDisabledLines.getEslintDisabledLines({
         ruleName: context.id,
@@ -146,7 +149,10 @@ const sortVariableDeclarations = createEslintRule.createEslintRule({
             (options.partitionByComment &&
               isPartitionComment.hasPartitionComment(
                 options.partitionByComment,
-                getCommentsBefore.getCommentsBefore(declaration, sourceCode),
+                getCommentsBefore.getCommentsBefore({
+                  node: declaration,
+                  sourceCode,
+                }),
               )) ||
             (options.partitionByNewLine &&
               lastSortingNode &&
@@ -228,6 +234,7 @@ const sortVariableDeclarations = createEslintRule.createEslintRule({
           partitionByNewLine: commonJsonSchemas.partitionByNewLineJsonSchema,
           specialCharacters: commonJsonSchemas.specialCharactersJsonSchema,
           ignoreCase: commonJsonSchemas.ignoreCaseJsonSchema,
+          alphabet: commonJsonSchemas.alphabetJsonSchema,
           locales: commonJsonSchemas.localesJsonSchema,
           order: commonJsonSchemas.orderJsonSchema,
           type: commonJsonSchemas.typeJsonSchema,

package/dist/utils/alphabet.js

@@ -0,0 +1,385 @@
+'use strict'
+var __defProp = Object.defineProperty
+var __defNormalProp = (obj, key, value) =>
+  key in obj
+    ? __defProp(obj, key, {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value,
+      })
+    : (obj[key] = value)
+var __publicField = (obj, key, value) =>
+  __defNormalProp(obj, typeof key !== 'symbol' ? key + '' : key, value)
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+const naturalOrderby = require('natural-orderby')
+const convertBooleanToSign = require('./convert-boolean-to-sign.js')
+class Alphabet {
+  constructor(characters) {
+    __publicField(this, '_characters', [])
+    this._characters = characters
+  }
+  /**
+   * Generates an alphabet from the given characters.
+   * @param {string|string[]} values - The characters to generate the alphabet from
+   * @returns {Alphabet} - The wrapped alphabet
+   */
+  static generateFrom(values) {
+    let arrayValues = typeof values === 'string' ? [...values] : values
+    if (arrayValues.length !== new Set(arrayValues).size) {
+      throw new Error('The alphabet must not contain repeated characters')
+    }
+    if (arrayValues.some(value => value.length !== 1)) {
+      throw new Error('The alphabet must contain single characters')
+    }
+    return new Alphabet(
+      arrayValues.map(value =>
+        Alphabet._convertCodepointToCharacter(value.codePointAt(0)),
+      ),
+    )
+  }
+  /**
+   * Generates an alphabet containing relevant characters from the Unicode
+   * standard. Contains the Unicode planes 0 and 1.
+   * @returns {Alphabet} - The generated alphabet
+   */
+  static generateRecommendedAlphabet() {
+    return Alphabet._generateAlphabetToRange(131071 + 1)
+  }
+  /**
+   * Generates an alphabet containing all characters from the Unicode standard
+   * except for irrelevant Unicode planes.
+   * Contains the Unicode planes 0, 1, 2 and 3.
+   * @returns {Alphabet} - The generated alphabet
+   */
+  static generateCompleteAlphabet() {
+    return Alphabet._generateAlphabetToRange(262143 + 1)
+  }
+  static _convertCodepointToCharacter(codePoint) {
+    let character = String.fromCodePoint(codePoint)
+    let lowercaseCharacter = character.toLowerCase()
+    let uppercaseCharacter = character.toUpperCase()
+    return {
+      value: character,
+      codePoint,
+      ...(lowercaseCharacter === character
+        ? null
+        : {
+            lowercaseCharacterCodePoint: lowercaseCharacter.codePointAt(0),
+          }),
+      ...(uppercaseCharacter === character
+        ? null
+        : {
+            uppercaseCharacterCodePoint: uppercaseCharacter.codePointAt(0),
+          }),
+    }
+  }
+  /**
+   * Generates an alphabet containing relevant characters from the Unicode
+   * standard.
+   * @param {number} maxCodePoint - The maximum code point to generate the
+   * alphabet to
+   * @returns {Alphabet} - The generated alphabet
+   */
+  static _generateAlphabetToRange(maxCodePoint) {
+    let totalCharacters = Array.from({ length: maxCodePoint }, (_, i) =>
+      Alphabet._convertCodepointToCharacter(i),
+    )
+    return new Alphabet(totalCharacters)
+  }
+  /**
+   * For each character with a lower and upper case, permutes the two cases
+   * so that the alphabet is ordered by the case priority entered.
+   * @param {string} casePriority - The case to prioritize
+   * @returns {Alphabet} - The same alphabet instance with the cases prioritized
+   * @example
+   * Alphabet.generateFrom('aAbBcdCD')
+   * .prioritizeCase('uppercase')
+   * // Returns 'AaBbCDcd'
+   */
+  prioritizeCase(casePriority) {
+    let charactersWithCase = this._getCharactersWithCase()
+    let parsedIndexes = /* @__PURE__ */ new Set()
+    let indexByCodePoints = this._characters.reduce(
+      (indexByCodePoint, character, index) => {
+        indexByCodePoint[character.codePoint] = index
+        return indexByCodePoint
+      },
+      {},
+    )
+    for (let { character, index } of charactersWithCase) {
+      if (parsedIndexes.has(index)) {
+        continue
+      }
+      parsedIndexes.add(index)
+      let otherCharacterIndex =
+        indexByCodePoints[
+          character.uppercaseCharacterCodePoint ??
+            character.lowercaseCharacterCodePoint
+        ]
+      if (otherCharacterIndex === void 0) {
+        continue
+      }
+      parsedIndexes.add(otherCharacterIndex)
+      let isCharacterUppercase = !character.uppercaseCharacterCodePoint
+      if (isCharacterUppercase) {
+        if (
+          (casePriority === 'uppercase' && index < otherCharacterIndex) ||
+          (casePriority === 'lowercase' && index > otherCharacterIndex)
+        ) {
+          continue
+        }
+      } else {
+        if (
+          (casePriority === 'uppercase' && index > otherCharacterIndex) ||
+          (casePriority === 'lowercase' && index < otherCharacterIndex)
+        ) {
+          continue
+        }
+      }
+      this._characters[index] = this._characters[otherCharacterIndex]
+      this._characters[otherCharacterIndex] = character
+    }
+    return this
+  }
+  /**
+   * Adds specific characters to the end of the alphabet.
+   * @param {string|string[]} values - The characters to push to the alphabet
+   * @returns {Alphabet} - The same alphabet instance without the specified
+   * characters
+   * @example
+   * Alphabet.generateFrom('ab')
+   * .pushCharacters('cd')
+   * // Returns 'abcd'
+   */
+  pushCharacters(values) {
+    let arrayValues = typeof values === 'string' ? [...values] : values
+    let valuesSet = new Set(arrayValues)
+    let valuesAlreadyExisting = this._characters.filter(({ value }) =>
+      valuesSet.has(value),
+    )
+    if (valuesAlreadyExisting.length > 0) {
+      throw new Error(
+        `The alphabet already contains the characters ${valuesAlreadyExisting
+          .slice(0, 5)
+          .map(({ value }) => value)
+          .join(', ')}`,
+      )
+    }
+    if (arrayValues.some(value => value.length !== 1)) {
+      throw new Error('Only single characters may be pushed')
+    }
+    this._characters.push(
+      ...[...valuesSet].map(value =>
+        Alphabet._convertCodepointToCharacter(value.codePointAt(0)),
+      ),
+    )
+    return this
+  }
+  /**
+   * Permutes characters with cases so that all characters with the entered case
+   * are put before the other characters.
+   * @param {string} caseToComeFirst - The case to put before the other
+   * characters
+   * @returns {Alphabet} - The same alphabet instance with all characters with
+   * case before all the characters with the other case
+   */
+  placeAllWithCaseBeforeAllWithOtherCase(caseToComeFirst) {
+    let charactersWithCase = this._getCharactersWithCase()
+    let orderedCharacters = [
+      ...charactersWithCase.filter(character =>
+        caseToComeFirst === 'uppercase'
+          ? !character.character.uppercaseCharacterCodePoint
+          : character.character.uppercaseCharacterCodePoint,
+      ),
+      ...charactersWithCase.filter(character =>
+        caseToComeFirst === 'uppercase'
+          ? character.character.uppercaseCharacterCodePoint
+          : !character.character.uppercaseCharacterCodePoint,
+      ),
+    ]
+    for (let [i, element] of charactersWithCase.entries()) {
+      this._characters[element.index] = orderedCharacters[i].character
+    }
+    return this
+  }
+  /**
+   * Places a specific character right before another character in the alphabet.
+   * @param {object} params - The parameters for the operation
+   * @param {string} params.characterBefore - The character to come before
+   * characterAfter
+   * @param {string} params.characterAfter - The target character
+   * @returns {Alphabet} - The same alphabet instance with the specific
+   * character prioritized
+   * @example
+   * Alphabet.generateFrom('ab-cd/')
+   * .placeCharacterBefore({ characterBefore: '/', characterAfter: '-' })
+   * // Returns 'ab/-cd'
+   */
+  placeCharacterBefore({ characterBefore, characterAfter }) {
+    return this._placeCharacterBeforeOrAfter({
+      characterBefore,
+      characterAfter,
+      type: 'before',
+    })
+  }
+  /**
+   * Places a specific character right after another character in the alphabet.
+   * @param {object} params - The parameters for the operation
+   * @param {string} params.characterBefore - The target character
+   * @param {string} params.characterAfter - The character to come after
+   * characterBefore
+   * @returns {Alphabet} - The same alphabet instance with the specific
+   * character prioritized
+   * @example
+   * Alphabet.generateFrom('ab-cd/')
+   * .placeCharacterAfter({ characterBefore: '/', characterAfter: '-' })
+   * // Returns 'abcd/-'
+   */
+  placeCharacterAfter({ characterBefore, characterAfter }) {
+    return this._placeCharacterBeforeOrAfter({
+      characterBefore,
+      characterAfter,
+      type: 'after',
+    })
+  }
+  /**
+   * Removes specific characters from the alphabet by their range.
+   * @param {object} range - The Unicode range to remove characters from
+   * @param {number} range.start - The starting Unicode codepoint
+   * @param {number} range.end - The ending Unicode codepoint
+   * @returns {Alphabet} - The same alphabet instance without the characters
+   * from the specified range
+   */
+  removeUnicodeRange({ start, end }) {
+    this._characters = this._characters.filter(
+      ({ codePoint }) => codePoint < start || codePoint > end,
+    )
+    return this
+  }
+  /**
+   * Sorts the alphabet by the sorting function provided.
+   * @param {Function} sortingFunction - The sorting function to use
+   * @returns {Alphabet} - The same alphabet instance sorted by the sorting function provided
+   */
+  sortBy(sortingFunction) {
+    this._characters.sort((a, b) => sortingFunction(a.value, b.value))
+    return this
+  }
+  /**
+   * Removes specific characters from the alphabet.
+   * @param {string|string[]} values - The characters to remove from the
+   * alphabet
+   * @returns {Alphabet} - The same alphabet instance without the specified
+   * characters
+   * @example
+   * Alphabet.generateFrom('abcd')
+   * .removeCharacters('dcc')
+   * // Returns 'ab'
+   */
+  removeCharacters(values) {
+    this._characters = this._characters.filter(
+      ({ value }) => !values.includes(value),
+    )
+    return this
+  }
+  /**
+   * Sorts the alphabet by the natural order of the characters using
+   * `natural-orderby`.
+   * @param {string} locale - The locale to use for sorting
+   * @returns {Alphabet} - The same alphabet instance sorted by the natural
+   * order of the characters
+   */
+  sortByNaturalSort(locale) {
+    let naturalCompare = naturalOrderby.compare({
+      locale,
+    })
+    return this.sortBy((a, b) => naturalCompare(a, b))
+  }
+  /**
+   * Sorts the alphabet by the character code point.
+   * @returns {Alphabet} - The same alphabet instance sorted by the character
+   * code point
+   */
+  sortByCharCodeAt() {
+    return this.sortBy((a, b) =>
+      convertBooleanToSign.convertBooleanToSign(
+        a.charCodeAt(0) > b.charCodeAt(0),
+      ),
+    )
+  }
+  /**
+   * Sorts the alphabet by the locale order of the characters.
+   * @param {Intl.LocalesArgument} locales - The locales to use for sorting
+   * @returns {Alphabet} - The same alphabet instance sorted by the locale
+   * order of the characters
+   */
+  sortByLocaleCompare(locales) {
+    return this.sortBy((a, b) => a.localeCompare(b, locales))
+  }
+  /**
+   * Retrieves the characters from the alphabet.
+   * @returns {string} The characters from the alphabet
+   */
+  getCharacters() {
+    return this._characters.map(({ value }) => value).join('')
+  }
+  /**
+   * Reverses the alphabet.
+   * @returns {Alphabet} - The same alphabet instance reversed
+   * @example
+   * Alphabet.generateFrom('ab')
+   * .reverse()
+   * // Returns 'ba'
+   */
+  reverse() {
+    this._characters.reverse()
+    return this
+  }
+  _placeCharacterBeforeOrAfter({ characterBefore, characterAfter, type }) {
+    let indexOfCharacterAfter = this._characters.findIndex(
+      ({ value }) => value === characterAfter,
+    )
+    let indexOfCharacterBefore = this._characters.findIndex(
+      ({ value }) => value === characterBefore,
+    )
+    if (indexOfCharacterAfter === -1) {
+      throw new Error(`Character ${characterAfter} not found in alphabet`)
+    }
+    if (indexOfCharacterBefore === -1) {
+      throw new Error(`Character ${characterBefore} not found in alphabet`)
+    }
+    if (indexOfCharacterBefore <= indexOfCharacterAfter) {
+      return this
+    }
+    this._characters.splice(
+      type === 'before' ? indexOfCharacterAfter : indexOfCharacterBefore + 1,
+      0,
+      this._characters[
+        type === 'before' ? indexOfCharacterBefore : indexOfCharacterAfter
+      ],
+    )
+    this._characters.splice(
+      type === 'before' ? indexOfCharacterBefore + 1 : indexOfCharacterAfter,
+      1,
+    )
+    return this
+  }
+  _getCharactersWithCase() {
+    return this._characters
+      .map((character, index) => {
+        if (
+          !character.uppercaseCharacterCodePoint &&
+          !character.lowercaseCharacterCodePoint
+        ) {
+          return null
+        }
+        return {
+          character,
+          index,
+        }
+      })
+      .filter(element => element !== null)
+  }
+}
+exports.Alphabet = Alphabet