• enum is a new LexicalDeclaration binding form, similar to let or const.

• typeof enum is object; similar to Array, it's just a special Object (more below)

• EnumDeclaration with no BindingIdentifier creates const bindings corresponding to each EnumEntryName:

  enum {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
  }
  

  Is equivalent to:

  const SUNDAY = 0;
  const MONDAY = 1;
  const TUESDAY = 2;
  const WEDNESDAY = 3;
  const THURSDAY = 4;
  const FRIDAY = 5;
  const SATURDAY = 6;
  

• EnumDeclaration or EnumExpression with a BindingIdentifier creates:

  • A proto-less, frozen object;

  • Creates PropertyName corresponding to each EnumEntryName:

    enum DaysOfWeek {
      SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
    }
    
    const DaysOfWeek = enum {
      SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY    
    };
    

    Is approximately* equivalent to:

    const DaysOfWeek = Object.freeze(
      Object.create(null, {
        [Symbol.enumSize]: {
          // Specification can define better semantics for deriving 
          // and storing the size of the enum object (internal slot)
          value: 7
        }, 
        [Symbol.iterator]: {
          * value() {
            // Specification can define better semantics for deriving 
            // and storing keys and values (internal slot)
            let keys = Object.keys(DaysOfWeek); 
            let values = Object.values(DaysOfWeek);
            let index = 0;
            while (index < keys.length) {
              yield [keys[index], values[index]];
              index++;
            }
          }
        },
        SUNDAY: { value: 0, enumerable: true },
        MONDAY: { value: 1, enumerable: true },
        TUESDAY: { value: 2, enumerable: true },
        WEDNESDAY: { value: 3, enumerable: true },
        THURSDAY: { value: 4, enumerable: true },
        FRIDAY: { value: 5, enumerable: true },
        SATURDAY: { value: 6, enumerable: true },
      })
    );
    
    for (let [day, value] of DaysOfWeek) { console.log(value, day) }
    
    /*
      0 SUNDAY
      1 MONDAY
      2 TUESDAY
      3 WEDNESDAY
      4 THURSDAY
      5 FRIDAY
      6 SATURDAY    
     */
    

• EnumDeclaration or EnumExpression will set the value of each entry to an integer, starting at 0 and incrementing by 1 for each entry.

• EnumDeclaration may have EnumEntryName inline assignment overrides. If an entry has an inline assignment, the default value is incremented as normal, but not used for that entry.

  enum {
    FOO, 
    BAR = _AssignmentExpression_, 
    BAZ, 
  }
  

  Is equivalent to:

  const FOO = 0;
  const BAR = _AssignmentExpression_;
  const BAZ = 2;
  

  EnumDeclaration (with BindingIdentifier) or EnumExpression example:

  enum Things {
    FOO, 
    BAR = _AssignmentExpression_, 
    BAZ, 
  }
  
  const Things = enum {
    FOO, 
    BAR = _AssignmentExpression_, 
    BAZ, 
  };
  

  Is approximately equivalent to:

  const DaysOfWeek = Object.freeze(
    Object.create(null, {
      /*
      Assume Symbol.enumSize and Symbol.iterator
       */
      FOO: { value: 0, enumerable: true },
      BAR: { value: _AssignmentExpression_, enumerable: true },
      BAZ: { value: 2, enumerable: true },
    })
  );
  

  Of course, this means that the value of an enum entry can be whatever you want it to be:

  
  // todo
  

• EnumDeclaration may have ComputedPropertyName as EnumEntryName:

  • TODO: Am I sure about this?

  enum {
    FOO, 
    ["BAR"], 
    BAZ, 
  }
  

  Is equivalent to:

  const FOO = 0;
  const BAR = 1;
  const BAZ = 2;
  

  EnumDeclaration (with BindingIdentifier) or EnumExpression example:

  enum Things {
    FOO, 
    [Symbol(...)], 
    BAZ, 
  }
  
  const Things = enum {
    FOO, 
    [Symbol(...)], 
    BAZ, 
  };
  

  Is approximately equivalent to:

  const DaysOfWeek = Object.freeze(
    Object.create(null, {
      /*
      Assume Symbol.enumSize and Symbol.iterator
       */
      FOO: { value: 0, enumerable: true },
      [Symbol(...)]: { value: 1, enumerable: true },
      BAZ: { value: 2, enumerable: true },
    })
  );
  

• EnumDeclaration may not have duplicate EnumEntryName:

  • These throw exceptions:

    enum {
      FOO, 
      FOO
    }
    

    enum {
      FOO, 
      ["BAR"], 
      BAR, 
    }
    

• EnumDeclaration with an EnumValueMap to populate the values of the Enum:

  function EnumValueMap(key, index) {
    return 1 << index;
  }
  
  enum via EnumValueMap {
    SUNDAY,
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
  }
  
  // Is equivalent to: 
  
  const SUNDAY    = EnumValueMap(SV(SUNDAY), 0);   // 0b00000001
  const MONDAY    = EnumValueMap(SV(MONDAY), 1);   // 0b00000010
  const TUESDAY   = EnumValueMap(SV(TUESDAY), 2);  // 0b00000100
  const WEDNESDAY = EnumValueMap(SV(WEDNESDAY), 3);// 0b00001000
  const THURSDAY  = EnumValueMap(SV(THURSDAY), 4); // 0b00010000
  const FRIDAY    = EnumValueMap(SV(FRIDAY), 5);   // 0b00100000
  const SATURDAY  = EnumValueMap(SV(SATURDAY), 6); // 0b01000000
  

  And the BindingIdentifier example:

  function EnumValueMap(key, index) {
    return 1 << index;
  }
  
  enum DaysOfWeekAsBits via EnumValueMap {
    SUNDAY,
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
  }
  

  Is approximately equivalent to:

  const DaysOfWeekAsBits = Object.freeze(
    Object.create(null, {
      [Symbol.enumSize]: {
        // Specification can define better semantics for deriving 
        // and storing the size of the enum object (internal slot)
        value: 7
      }, 
      [Symbol.iterator]: {
        * value() {
          // Specification can define better semantics for deriving 
          // and storing keys and values (internal slot)
          let keys = Object.keys(DaysOfWeekAsBits); 
          let values = Object.values(DaysOfWeekAsBits);
          let index = 0;
          while (index < keys.length) {
            yield [keys[index], values[index]];
            index++;
          }
        }
      },
      SUNDAY: { value: EnumValueMap(SV(SUNDAY), 0), enumerable: true },
      MONDAY: { value: EnumValueMap(SV(MONDAY), 1), enumerable: true },
      TUESDAY: { value: EnumValueMap(SV(TUESDAY), 2), enumerable: true },
      WEDNESDAY: { value: EnumValueMap(SV(WEDNESDAY), 3), enumerable: true },
      THURSDAY: { value: EnumValueMap(SV(THURSDAY), 4), enumerable: true },
      FRIDAY: { value: EnumValueMap(SV(FRIDAY), 5), enumerable: true },
      SATURDAY: { value: EnumValueMap(SV(SATURDAY), 6), enumerable: true },
    })
  );
  
  for (let [day, value] of DaysOfWeekAsBits) { console.log(value, day) }
  
  /*
    0b00000001 SUNDAY
    0b00000010 MONDAY
    0b00000100 TUESDAY
    0b00001000 WEDNESDAY
    0b00010000 THURSDAY
    0b00100000 FRIDAY
    0b01000000 SATURDAY    
   */
  

  WebIDL could specify its enum as using a default EnumValueMap; ie. https://heycam.github.io/webidl/#idl-enumeration might update its definition:

  An enumeration is a definition (matching Enum) used to declare a type whose valid values are a set of predefined strings.

  To:

  An enumeration is a definition (matching Enum) used to declare a type whose valid values are a set of predefined strings.

  An ECMAScript implementation of WebIDL enum would use a String EnumValueMap.

  enum RTCPeerConnectionState via String { 
    new,
    connecting,
    connected,
    disconnected,
    failed,
    closed,
  };
  

  Is approximately equivalent to:

  const RTCPeerConnectionState =Object.freeze(
    Object.create(null, {
      [Symbol.enumSize]: {
        // Specification can define better semantics for deriving 
        // and storing the size of the enum object (internal slot)
        value: 6
      }, 
      [Symbol.iterator]: {
        * value() {
          // Specification can define better semantics for deriving 
          // and storing keys and values (internal slot)
          let keys = Object.keys(RTCPeerConnectionState); 
          let values = Object.values(RTCPeerConnectionState);
          let index = 0;
          while (index < keys.length) {
            yield [keys[index], values[index]];
            index++;
          }
        }
      },
      // Note that this case illustrates that it's ok for the 
      // for the second argument to be ignored.
      new: { value: String(SV(new)), enumerable: true },
      connecting: { value: String(SV(connecting)), enumerable: true },
      connected: { value: String(SV(connected)), enumerable: true },
      disconnected: { value: String(SV(disconnected)), enumerable: true },
      failed: { value: String(SV(failed)), enumerable: true },
      closed: { value: String(SV(closed)), enumerable: true },
    })
  );
  

* Approximately means that it doesn't fully represent all of the semantics.