docs: def pack(fmt, *values, **kwargs):
      """Pack the values according to the format string and return a new BitStream.
  
      fmt -- A single string or a list of strings with comma separated tokens
             describing how to create the BitStream.
      values -- Zero or more values to pack according to the format.
      kwargs -- A dictionary or keyword-value pairs - the keywords used in the
                format string will be replaced with their given value.
  
      Token examples: 'int:12'    : 12 bits as a signed integer
                      'uint:8'    : 8 bits as an unsigned integer
                      'float:64'  : 8 bytes as a big-endian float
                      'intbe:16'  : 2 bytes as a big-endian signed integer
                      'uintbe:16' : 2 bytes as a big-endian unsigned integer
                      'intle:32'  : 4 bytes as a little-endian signed integer
                      'uintle:32' : 4 bytes as a little-endian unsigned integer
                      'floatle:64': 8 bytes as a little-endian float
                      'intne:24'  : 3 bytes as a native-endian signed integer
                      'uintne:24' : 3 bytes as a native-endian unsigned integer
                      'floatne:32': 4 bytes as a native-endian float
                      'hex:80'    : 80 bits as a hex string
                      'oct:9'     : 9 bits as an octal string
                      'bin:1'     : single bit binary string
                      'ue' / 'uie': next bits as unsigned exp-Golomb code
                      'se' / 'sie': next bits as signed exp-Golomb code
                      'bits:5'    : 5 bits as a bitstring object
                      'bytes:10'  : 10 bytes as a bytes object
                      'bool'      : 1 bit as a bool
                      'pad:3'     : 3 zero bits as padding
  
      >>> s = pack('uint:12, bits', 100, '0xffe')
      >>> t = pack(['bits', 'bin:3'], s, '111')
      >>> u = pack('uint:8=a, uint:8=b, uint:55=a', a=6, b=44)
  
      """
      tokens = []
      if isinstance(fmt, basestring):
          fmt = [fmt]
      try:
          for f_item in fmt:
              _, tkns = tokenparser(f_item, tuple(sorted(kwargs.keys())))
              tokens.extend(tkns)
      except ValueError as e:
          raise CreationError(*e.args)
      value_iter = iter(values)
      s = BitStream()
      try:
          for name, length, value in tokens:
              # If the value is in the kwd dictionary then it takes precedence.
              if value in kwargs:
                  value = kwargs[value]
              # If the length is in the kwd dictionary then use that too.
              if length in kwargs:
                  length = kwargs[length]
              # Also if we just have a dictionary name then we want to use it
              if name in kwargs and length is None and value is None:
                  s.append(kwargs[name])
                  continue
              if length is not None:
                  length = int(length)
              if value is None and name != 'pad':
                  # Take the next value from the ones provided
                  value = next(value_iter)
              s._append(BitStream._init_with_token(name, length, value))
      except StopIteration:
          raise CreationError("Not enough parameters present to pack according to the "
                              "format. {0} values are needed.", len(tokens))
      try:
          next(value_iter)
      except StopIteration:
          # Good, we've used up all the *values.
          return s
      raise CreationError("Too many parameters present to pack according to the format.")